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

package/src/core/applications/local-application.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+
+import { AbstractApplication } from "./application";
+import type { LocalApplicationData } from "./local-application";
+import { LocalApplication } from "./local-application";
+
+const STUDIO_APP: LocalApplicationData = {
+  host: "localhost",
+  port: 3333,
+  type: "studio",
+};
+
+const CORE_APP: LocalApplicationData = {
+  host: "127.0.0.1",
+  port: 4444,
+  type: "coreApp",
+};
+
+describe("LocalApplication", () => {
+  it("is an instance of AbstractApplication", () => {
+    expect(new LocalApplication(STUDIO_APP)).toBeInstanceOf(
+      AbstractApplication,
+    );
+  });
+
+  describe("type", () => {
+    it("inherits the type from LocalApplicationData", () => {
+      expect(new LocalApplication(STUDIO_APP).type).toBe("studio");
+      expect(new LocalApplication(CORE_APP).type).toBe("coreApp");
+    });
+
+    it("has the correct TypeScript type", () => {
+      const app = new LocalApplication(STUDIO_APP);
+      expectTypeOf(app.type).toEqualTypeOf<"studio" | "coreApp">();
+    });
+  });
+
+  describe("id", () => {
+    it("generates a deterministic id from host and port", () => {
+      expect(new LocalApplication(STUDIO_APP).id).toBe("localhost-3333");
+    });
+
+    it("is stable across instances with the same data", () => {
+      expect(new LocalApplication(STUDIO_APP).id).toBe(
+        new LocalApplication(STUDIO_APP).id,
+      );
+    });
+
+    it("differs when host or port differs", () => {
+      const a = new LocalApplication(STUDIO_APP);
+      const b = new LocalApplication(CORE_APP);
+      expect(a.id).not.toBe(b.id);
+    });
+  });
+
+  describe("title", () => {
+    it("formats as host:port", () => {
+      expect(new LocalApplication(STUDIO_APP).title).toBe("localhost:3333");
+      expect(new LocalApplication(CORE_APP).title).toBe("127.0.0.1:4444");
+    });
+  });
+
+  describe("href", () => {
+    it("generates a /local/ route", () => {
+      expect(new LocalApplication(STUDIO_APP).href).toBe(
+        "/local/localhost-3333",
+      );
+      expect(new LocalApplication(CORE_APP).href).toBe("/local/127.0.0.1-4444");
+    });
+  });
+
+  describe("initials", () => {
+    it("derives initials from the title", () => {
+      // "localhost:3333" → strip symbols → "localhost3333"
+      // → alpha segment "localhost" + numeric segment "3333" → "L" + "3" = "L3"
+      expect(new LocalApplication(STUDIO_APP).initials).toBe("L3");
+    });
+
+    it("handles numeric-only titles (e.g. IP address)", () => {
+      // "127.0.0.1:4444" → strip symbols → "1270014444"
+      // → single numeric segment → first two chars → "12"
+      expect(new LocalApplication(CORE_APP).initials).toBe("12");
+    });
+  });
+
+  describe("toProtocolResource", () => {
+    it("throws because local applications have no protocol representation", () => {
+      expect(() =>
+        new LocalApplication(STUDIO_APP).toProtocolResource(),
+      ).toThrow();
+    });
+  });
+});

package/src/core/applications/local-application.ts

@@ -0,0 +1,56 @@
+import { AbstractApplication } from "./application";
+
+/**
+ * Raw data for a local application discovered by the CLI dev server.
+ *
+ * @experimental
+ * @public
+ */
+export interface LocalApplicationData {
+  host: string;
+  port: number;
+  type: "studio" | "coreApp";
+}
+
+/**
+ * An Application wrapping a locally-discovered CLI application.
+ * Provides a deterministic id, title and href suitable for use in navigation.
+ *
+ * @internal
+ */
+export class LocalApplication extends AbstractApplication<
+  "studio" | "coreApp",
+  never
+> {
+  readonly localApplication: LocalApplicationData;
+
+  constructor(localApplication: LocalApplicationData) {
+    super(localApplication.type);
+    this.localApplication = localApplication;
+  }
+
+  get id(): string {
+    const { host, port } = this.localApplication;
+    return `${host}-${port}`;
+  }
+
+  get title(): string {
+    const { host, port } = this.localApplication;
+    return `${host}:${port}`;
+  }
+
+  get href(): string {
+    return `/local/${this.id}`;
+  }
+
+  get url(): URL {
+    const { host, port } = this.localApplication;
+    return new URL(`http://${host}:${port}`);
+  }
+
+  toProtocolResource(): never {
+    throw new Error(
+      "LocalApplication cannot be serialized to a protocol resource",
+    );
+  }
+}

package/src/core/canvases.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+
+import { CANVAS_DATA } from "./__tests__/__fixtures__";
+import { CanvasApplication } from "./canvases";
+
+const setup = () => new CanvasApplication(CANVAS_DATA);
+
+describe("CanvasResource", () => {
+  it("should have a type of canvas", () => {
+    const resource = setup();
+    expect(resource.type).toBe("canvas");
+  });
+
+  it("should have a to of /canvas", () => {
+    const resource = setup();
+    expect(resource.href).toBe("canvas");
+  });
+
+  it("should have a name of Canvas", () => {
+    const resource = setup();
+    expect(resource.title).toBe("Canvas");
+  });
+
+  it("should have an id", () => {
+    const resource = setup();
+    expect(resource.id).toBe("cac1Na6lwtEI");
+  });
+
+  it("should implement the toProtocolResource method", () => {
+    const resource = setup();
+    expect(resource.toProtocolResource()).toMatchInlineSnapshot(`
+      {
+        "id": "cac1Na6lwtEI",
+        "type": "canvas",
+      }
+    `);
+  });
+});

package/src/core/canvases.ts

@@ -0,0 +1,81 @@
+import type { CanvasResource as ProtocolCanvasResource } from "@sanity/message-protocol";
+import { z } from "zod";
+
+import { AbstractApplication } from "./applications/application";
+import { OrganizationId } from "./organizations";
+
+/**
+ * Canvas ID schema, branded for type safety.
+ * @public
+ */
+const CanvasId = z.string().nonempty().brand("CanvasId");
+
+/**
+ * Canvas ID type, branded for type safety.
+ * @public
+ */
+export type CanvasId = z.output<typeof CanvasId>;
+
+/**
+ * Validates and brands a string as a CanvasId.
+ * @public
+ */
+export function brandCanvasId(id: string): CanvasId {
+  return CanvasId.parse(id);
+}
+
+const Canvas = z.object({
+  id: CanvasId,
+  organizationId: OrganizationId,
+  status: z.enum(["active", "provisioning"]),
+});
+
+/**
+ * Represents a Canvas resource as returned from the API.
+ * @public
+ */
+export type Canvas = z.output<typeof Canvas>;
+
+/**
+ * Validates and parses a raw API response into a branded
+ * Canvas.
+ * @public
+ */
+export function parseCanvas(data: unknown): Canvas {
+  return Canvas.parse(data);
+}
+
+/**
+ * Whilst the constructor takes an organization's canvas resource the existance
+ * therefore implies the organization has access to the canvas application which
+ * is what workbench most importantly wants to know.
+ * @public
+ */
+export class CanvasApplication extends AbstractApplication<"canvas"> {
+  readonly canvas: Canvas;
+
+  constructor(canvas: Canvas) {
+    super("canvas");
+
+    this.canvas = canvas;
+  }
+
+  get id(): CanvasId {
+    return this.canvas.id;
+  }
+
+  get href(): string {
+    return "canvas";
+  }
+
+  get title(): string {
+    return "Canvas";
+  }
+
+  toProtocolResource(): ProtocolCanvasResource {
+    return {
+      type: "canvas",
+      id: this.id,
+    } satisfies ProtocolCanvasResource;
+  }
+}

package/src/core/config.ts

@@ -0,0 +1,34 @@
+import type { OrganizationId } from "./organizations";
+
+/**
+ * Workbench configuration.
+ *
+ * @public
+ */
+interface Config {
+  /**
+   * The organization ID to use when rendering the workbench.
+   */
+  organizationId?: string;
+}
+
+/**
+ * The resolved configuration after processing
+ * and validating the provided config.
+ *
+ * @public
+ */
+type ResolvedConfig = Omit<Config, "organizationId"> & {
+  organizationId: OrganizationId;
+};
+
+/**
+ * Options for rendering a remote module, such as a user application.
+ *
+ * @public
+ */
+interface RemoteModuleRenderOptions {
+  reactStrictMode?: boolean;
+}
+
+export type { Config, ResolvedConfig, RemoteModuleRenderOptions };

package/src/core/index.ts

@@ -0,0 +1,12 @@
+export * from "./applications/application";
+export * from "./applications/application-list";
+export * from "./applications/local-application";
+export * from "./canvases";
+export * from "./config";
+export * from "./log";
+export * from "./media-libraries";
+export * from "./organizations";
+export * from "./projects";
+export * from "./user-applications/core-app";
+export * from "./user-applications/studios";
+export * from "./user-applications/user-application";

package/src/{log → core/log}/index.ts

@@ -78,3 +78,15 @@ export function createLogger({
     debug: (message, context) => logAtLevel("debug", message, context),
   };
 }
+
+/**
+ * Shared workbench logger instance. Use this from both the workbench host
+ * and its remotes so lifecycle and diagnostic logs appear under a single
+ * namespace.
+ *
+ * @public
+ */
+export const logger: Logger = createLogger({
+  namespace: "sanity-workbench",
+  logLevel: "debug",
+});

package/src/core/media-libraries.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+
+import { MEDIA_LIBRARY_DATA } from "./__tests__/__fixtures__";
+import { MediaLibraryApplication } from "./media-libraries";
+
+const setup = () => new MediaLibraryApplication(MEDIA_LIBRARY_DATA);
+
+describe("MediaLibraryApplication", () => {
+  it("should have a type of media-library", () => {
+    const resource = setup();
+    expect(resource.type).toBe("media-library");
+  });
+
+  it("should have a to of /media", () => {
+    const resource = setup();
+    expect(resource.href).toBe("media");
+  });
+
+  it("should have a name of Media Library", () => {
+    const resource = setup();
+    expect(resource.title).toBe("Media Library");
+  });
+
+  it("should have an id", () => {
+    const resource = setup();
+    expect(resource.id).toBe("al34RQcBfuD7");
+  });
+
+  it("should implement the toProtocolResource method", () => {
+    const resource = setup();
+    expect(resource.toProtocolResource()).toMatchInlineSnapshot(`
+      {
+        "id": "al34RQcBfuD7",
+        "type": "media-library",
+      }
+    `);
+  });
+});

package/src/core/media-libraries.ts

@@ -0,0 +1,83 @@
+import type { MediaResource as ProtocolMediaResource } from "@sanity/message-protocol";
+import { z } from "zod";
+
+import { AbstractApplication } from "./applications/application";
+import { OrganizationId } from "./organizations";
+
+/**
+ * Canvas ID schema, branded for type safety.
+ * @public
+ */
+const MediaLibraryId = z.string().nonempty().brand("MediaLibraryId");
+
+/**
+ * MediaLibrary ID type, branded for type safety.
+ * @public
+ */
+export type MediaLibraryId = z.output<typeof MediaLibraryId>;
+
+/**
+ * Validates and brands a string as a MediaLibraryId.
+ * @public
+ */
+export function brandMediaLibraryId(id: string): MediaLibraryId {
+  return MediaLibraryId.parse(id);
+}
+
+const MediaLibrary = z.object({
+  id: MediaLibraryId,
+  organizationId: OrganizationId,
+  status: z.enum(["active", "provisioning"]),
+  aclMode: z.enum(["private", "public"]),
+});
+
+/**
+ * Represents a MediaLibrary resource as returned from the API.
+ * @public
+ */
+export type MediaLibrary = z.output<typeof MediaLibrary>;
+
+/**
+ * Validates and parses a raw API response into a branded
+ * MediaLibrary.
+ * @public
+ */
+export function parseMediaLibrary(data: unknown): MediaLibrary {
+  return MediaLibrary.parse(data);
+}
+
+/**
+ * Whilst the constructor takes an organization's media library resource the existance
+ * therefore implies the organization has access to the media library application which
+ * is what workbench most importantly wants to know.
+ * @public
+ */
+
+export class MediaLibraryApplication extends AbstractApplication<"media-library"> {
+  readonly library: MediaLibrary;
+
+  constructor(library: MediaLibrary) {
+    super("media-library");
+
+    this.library = library;
+  }
+
+  get id(): string {
+    return this.library.id;
+  }
+
+  get href(): string {
+    return "media";
+  }
+
+  get title(): string {
+    return "Media Library";
+  }
+
+  toProtocolResource(): ProtocolMediaResource {
+    return {
+      type: "media-library",
+      id: this.id,
+    } satisfies ProtocolMediaResource;
+  }
+}

package/src/core/organizations.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+
+import type {
+  Organization,
+  OrganizationId,
+  OrganizationMember,
+} from "./organizations";
+import { brandOrganizationId, parseOrganization } from "./organizations";
+
+describe("brandOrganizationId", () => {
+  it("brands a valid organization id", () => {
+    const id = brandOrganizationId("oABC123");
+    expect(id).toBe("oABC123");
+    expectTypeOf(id).toEqualTypeOf<OrganizationId>();
+  });
+
+  it("rejects an empty string", () => {
+    expect(() => brandOrganizationId("")).toThrow();
+  });
+
+  it("is not assignable from a plain string", () => {
+    expectTypeOf<OrganizationId>().branded.toEqualTypeOf<OrganizationId>();
+  });
+});
+
+describe("parseOrganization", () => {
+  const VALID_ORG = {
+    id: "org123",
+    name: "Sanity",
+    slug: "sanity",
+    createdAt: "2024-01-01T00:00:00Z",
+    updatedAt: "2024-01-01T00:00:00Z",
+    dashboardStatus: "enabled",
+    aiFeaturesStatus: "enabled",
+    defaultRoleName: "member",
+  };
+
+  const VALID_MEMBER = {
+    sanityUserId: "user1",
+    isCurrentUser: true,
+    user: {
+      id: "u1",
+      displayName: "Josh",
+      familyName: "Ellis",
+      givenName: "Josh",
+      middleName: null,
+      imageUrl: null,
+      email: "josh@sanity.io",
+      loginProvider: "google",
+    },
+    roles: [{ name: "admin", title: "Admin" }],
+  };
+
+  const VALID_ORG_FULL = {
+    ...VALID_ORG,
+    members: [VALID_MEMBER],
+    features: ["customLogo"],
+  };
+
+  it("parses a valid organization with members and features by default", () => {
+    const org = parseOrganization(VALID_ORG_FULL);
+    expect(org.name).toBe("Sanity");
+    expect(org.members).toHaveLength(1);
+    expect(org.features).toEqual(["customLogo"]);
+    expectTypeOf(org).toEqualTypeOf<Organization>();
+    expectTypeOf(org.id).toEqualTypeOf<OrganizationId>();
+  });
+
+  it("rejects missing required fields", () => {
+    expect(() => parseOrganization({ id: "org123" })).toThrow();
+  });
+
+  it("rejects missing members by default", () => {
+    expect(() => parseOrganization(VALID_ORG)).toThrow();
+  });
+
+  it("rejects invalid enum values", () => {
+    expect(() =>
+      parseOrganization({
+        ...VALID_ORG_FULL,
+        dashboardStatus: "invalid",
+      }),
+    ).toThrow();
+  });
+
+  it("strips unknown properties", () => {
+    const org = parseOrganization({
+      ...VALID_ORG_FULL,
+      unknownField: "should be stripped",
+    });
+    expect(org).not.toHaveProperty("unknownField");
+  });
+
+  it("parses without members when excluded", () => {
+    const org = parseOrganization(
+      { ...VALID_ORG, features: ["customLogo"] },
+      { includeMembers: false },
+    );
+    expect(org).not.toHaveProperty("members");
+    expect(org.features).toEqual(["customLogo"]);
+    expectTypeOf(org).toEqualTypeOf<Organization<false>>();
+  });
+
+  it("parses without features when excluded", () => {
+    const org = parseOrganization(
+      { ...VALID_ORG, members: [VALID_MEMBER] },
+      { includeFeatures: false },
+    );
+    expect(org).not.toHaveProperty("features");
+    expect(org.members).toHaveLength(1);
+    expectTypeOf(org).toEqualTypeOf<Organization<true, false>>();
+    expectTypeOf(org.members).toEqualTypeOf<OrganizationMember[]>();
+  });
+
+  it("parses base only when both excluded", () => {
+    const org = parseOrganization(VALID_ORG, {
+      includeMembers: false,
+      includeFeatures: false,
+    });
+    expect(org).not.toHaveProperty("members");
+    expect(org).not.toHaveProperty("features");
+    expectTypeOf(org).toEqualTypeOf<Organization<false, false>>();
+  });
+
+  it("parses with both members and features", () => {
+    const org = parseOrganization(VALID_ORG_FULL, {
+      includeMembers: true,
+      includeFeatures: true,
+    });
+    expect(org.members).toHaveLength(1);
+    expect(org.features).toEqual(["customLogo"]);
+    expectTypeOf(org).toEqualTypeOf<Organization<true, true>>();
+  });
+});