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

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/studio";
+export * from "./user-applications/user-application";

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"> {
+  private 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>>();
+  });
+});

package/src/core/organizations.ts

@@ -0,0 +1,115 @@
+import { z } from "zod";
+
+/**
+ * Organization ID schema, branded for type safety.
+ * @public
+ */
+export const OrganizationId = z.string().nonempty().brand("OrganizationId");
+
+/**
+ * Organization ID type, branded for type safety.
+ * @public
+ */
+export type OrganizationId = z.output<typeof OrganizationId>;
+
+/**
+ * Validates and brands a string as an OrganizationId.
+ * @public
+ */
+export function brandOrganizationId(id: string): OrganizationId {
+  return OrganizationId.parse(id);
+}
+
+const OrganizationMember = z.object({
+  sanityUserId: z.string(),
+  isCurrentUser: z.boolean(),
+  user: z.object({
+    id: z.string(),
+    displayName: z.string(),
+    familyName: z.string(),
+    givenName: z.string(),
+    middleName: z.string().nullable(),
+    imageUrl: z.string().nullable(),
+    email: z.string(),
+    loginProvider: z.string(),
+  }),
+  roles: z.array(
+    z.object({
+      name: z.string(),
+      title: z.string(),
+      description: z.string().optional(),
+    }),
+  ),
+});
+
+/**
+ * @public
+ */
+export type OrganizationMember = z.output<typeof OrganizationMember>;
+
+/**
+ * Organization schema — validates and brands API responses
+ * from the `/organizations/:id` endpoint.
+ * @public
+ */
+export const Organization = z.object({
+  id: OrganizationId,
+  name: z.string(),
+  slug: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  dashboardStatus: z.enum(["enabled", "disabled"]),
+  aiFeaturesStatus: z.enum(["enabled", "disabled"]),
+  defaultRoleName: z.string(),
+});
+
+/**
+ * Represents an organization with optional members and
+ * features arrays depending on the generic parameters.
+ * - `Organization` — base fields only (default)
+ * - `Organization<true>` — includes `members`
+ * - `Organization<true, true>` — includes both
+ * @public
+ */
+export type Organization<
+  IncludeMembers extends boolean = true,
+  IncludeFeatures extends boolean = true,
+> = z.output<typeof Organization> &
+  (IncludeMembers extends true ? { members: OrganizationMember[] } : unknown) &
+  (IncludeFeatures extends true ? { features: string[] } : unknown);
+
+/**
+ * Validates and parses a raw API response into a branded
+ * Organization. The options control which schema is used —
+ * matching what the API returns based on query params.
+ * @public
+ */
+export function parseOrganization<
+  IncludeMembers extends boolean = true,
+  IncludeFeatures extends boolean = true,
+>(
+  data: unknown,
+  options?: {
+    includeMembers?: IncludeMembers;
+    includeFeatures?: IncludeFeatures;
+  },
+): Organization<IncludeMembers, IncludeFeatures> {
+  const includeMembers = options?.includeMembers ?? true;
+  const includeFeatures = options?.includeFeatures ?? true;
+
+  const extensions = {
+    ...(includeMembers && {
+      members: z.array(OrganizationMember),
+    }),
+    ...(includeFeatures && {
+      features: z.array(z.string()),
+    }),
+  };
+
+  const schema =
+    Object.keys(extensions).length > 0
+      ? Organization.extend(extensions)
+      : Organization;
+
+  return schema.parse(data) as Organization<IncludeMembers, IncludeFeatures>;
+}

package/src/core/projects.test.ts

@@ -0,0 +1,248 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+
+import { brandOrganizationId } from "./organizations";
+import type { OrganizationId } from "./organizations";
+import type { Project, ProjectId, ProjectMember } from "./projects";
+import { brandProjectId, parseProject } from "./projects";
+
+describe("Project type", () => {
+  it("includes members and features by default", () => {
+    expectTypeOf<Project>().toHaveProperty("members");
+    expectTypeOf<Project>().toHaveProperty("features");
+  });
+
+  it("excludes members when IncludeMembers is false", () => {
+    expectTypeOf<Project<false>>().toHaveProperty("features");
+    expectTypeOf<
+      "members" extends keyof Project<false> ? true : false
+    >().toEqualTypeOf<false>();
+  });
+
+  it("excludes features when IncludeFeatures is false", () => {
+    expectTypeOf<Project<true, false>>().toHaveProperty("members");
+    expectTypeOf<
+      "features" extends keyof Project<true, false> ? true : false
+    >().toEqualTypeOf<false>();
+  });
+
+  it("excludes both when both are false", () => {
+    expectTypeOf<
+      "members" extends keyof Project<false, false> ? true : false
+    >().toEqualTypeOf<false>();
+    expectTypeOf<
+      "features" extends keyof Project<false, false> ? true : false
+    >().toEqualTypeOf<false>();
+  });
+
+  it("always includes base properties", () => {
+    expectTypeOf<Project>().toHaveProperty("id");
+    expectTypeOf<Project>().toHaveProperty("displayName");
+    expectTypeOf<Project>().toHaveProperty("organizationId");
+
+    expectTypeOf<Project<false, false>>().toHaveProperty("id");
+    expectTypeOf<Project<false, false>>().toHaveProperty("displayName");
+    expectTypeOf<Project<false, false>>().toHaveProperty("organizationId");
+  });
+
+  it("has branded id and organizationId types", () => {
+    expectTypeOf<Project["id"]>().toEqualTypeOf<ProjectId>();
+    expectTypeOf<Project["organizationId"]>().toEqualTypeOf<OrganizationId>();
+  });
+});
+
+describe("brandProjectId", () => {
+  it("brands a valid project id", () => {
+    const id = brandProjectId("abc123");
+    expect(id).toBe("abc123");
+    expectTypeOf(id).toEqualTypeOf<ProjectId>();
+  });
+
+  it("rejects an empty string", () => {
+    expect(() => brandProjectId("")).toThrow();
+  });
+
+  it("is not assignable from a plain string", () => {
+    expectTypeOf<ProjectId>().branded.toEqualTypeOf<ProjectId>();
+  });
+
+  it("is not assignable from OrganizationId", () => {
+    expectTypeOf<
+      OrganizationId extends ProjectId ? true : false
+    >().toEqualTypeOf<false>();
+  });
+});
+
+describe("parseProject", () => {
+  const VALID_PROJECT = {
+    id: "proj123",
+    displayName: "My Project",
+    studioHost: "my-project",
+    organizationId: brandOrganizationId("org123"),
+    metadata: {
+      integration: "cli",
+      color: "#ff0000",
+      initialTemplate: "blog",
+      cliInitializedAt: "2024-01-01T00:00:00Z",
+    },
+    isBlocked: false,
+    isDisabled: false,
+    isDisabledByUser: false,
+    activityFeedEnabled: true,
+    createdAt: "2024-01-01T00:00:00Z",
+    updatedAt: "2024-01-01T00:00:00Z",
+  };
+
+  const VALID_MEMBER = {
+    id: "member1",
+    createdAt: "2024-01-01T00:00:00Z",
+    updatedAt: "2024-01-01T00:00:00Z",
+    isCurrentUser: true,
+    isRobot: false,
+    roles: [{ name: "admin", title: "Admin", description: "Full access" }],
+  };
+
+  const VALID_PROJECT_FULL = {
+    ...VALID_PROJECT,
+    members: [VALID_MEMBER],
+    features: ["customDomain"],
+  };
+
+  it("parses a valid project with members and features by default", () => {
+    const project = parseProject(VALID_PROJECT_FULL);
+    expect(project.displayName).toBe("My Project");
+    expect(project.members).toHaveLength(1);
+    expect(project.features).toEqual(["customDomain"]);
+    expectTypeOf(project).toEqualTypeOf<Project>();
+    expectTypeOf(project.id).toEqualTypeOf<ProjectId>();
+    expectTypeOf(project.organizationId).toEqualTypeOf<OrganizationId>();
+  });
+
+  it("rejects missing required fields", () => {
+    expect(() => parseProject({ id: "proj123" })).toThrow();
+  });
+
+  it("rejects missing members by default", () => {
+    expect(() => parseProject(VALID_PROJECT)).toThrow();
+  });
+
+  it("strips unknown properties", () => {
+    const project = parseProject({
+      ...VALID_PROJECT_FULL,
+      unknownField: "should be stripped",
+    });
+    expect(project).not.toHaveProperty("unknownField");
+  });
+
+  it("parses without members when excluded", () => {
+    const project = parseProject(
+      { ...VALID_PROJECT, features: ["customDomain"] },
+      { includeMembers: false },
+    );
+    expect(project).not.toHaveProperty("members");
+    expect(project.features).toEqual(["customDomain"]);
+    expectTypeOf(project).toEqualTypeOf<Project<false>>();
+  });
+
+  it("parses without features when excluded", () => {
+    const project = parseProject(
+      { ...VALID_PROJECT, members: [VALID_MEMBER] },
+      { includeFeatures: false },
+    );
+    expect(project).not.toHaveProperty("features");
+    expect(project.members).toHaveLength(1);
+    expectTypeOf(project).toEqualTypeOf<Project<true, false>>();
+    expectTypeOf(project.members).toEqualTypeOf<ProjectMember[]>();
+  });
+
+  it("parses base only when both excluded", () => {
+    const project = parseProject(VALID_PROJECT, {
+      includeMembers: false,
+      includeFeatures: false,
+    });
+    expect(project).not.toHaveProperty("members");
+    expect(project).not.toHaveProperty("features");
+    expectTypeOf(project).toEqualTypeOf<Project<false, false>>();
+  });
+
+  it("parses with both members and features", () => {
+    const project = parseProject(VALID_PROJECT_FULL, {
+      includeMembers: true,
+      includeFeatures: true,
+    });
+    expect(project.members).toHaveLength(1);
+    expect(project.features).toEqual(["customDomain"]);
+    expectTypeOf(project).toEqualTypeOf<Project<true, true>>();
+  });
+
+  describe("metadata fields are optional", () => {
+    const BASE = {
+      ...VALID_PROJECT,
+      members: [VALID_MEMBER],
+      features: ["customDomain"],
+    };
+
+    it("parses with only the integration field", () => {
+      const project = parseProject({
+        ...BASE,
+        metadata: { integration: "cli" },
+      });
+      expect(project.metadata).toEqual({ integration: "cli" });
+    });
+
+    describe("metadata.integration", () => {
+      it('accepts "cli"', () => {
+        const project = parseProject({
+          ...BASE,
+          metadata: { integration: "cli" },
+        });
+        expect(project.metadata.integration).toBe("cli");
+      });
+
+      it('accepts "manage"', () => {
+        const project = parseProject({
+          ...BASE,
+          metadata: { integration: "manage" },
+        });
+        expect(project.metadata.integration).toBe("manage");
+      });
+
+      it("rejects an unknown value", () => {
+        expect(() =>
+          parseProject({
+            ...BASE,
+            metadata: { integration: "unknown" },
+          }),
+        ).toThrow();
+      });
+
+      it("rejects a missing integration field", () => {
+        expect(() =>
+          parseProject({ ...BASE, metadata: { color: "#ff0000" } }),
+        ).toThrow();
+      });
+    });
+
+    it("parses without metadata.color", () => {
+      const { color: _color, ...rest } = BASE.metadata;
+      const project = parseProject({ ...BASE, metadata: rest });
+      expect(project.metadata).not.toHaveProperty("color");
+    });
+
+    it("parses without metadata.externalStudioHost", () => {
+      const project = parseProject({ ...BASE, metadata: BASE.metadata });
+      expect(project.metadata).not.toHaveProperty("externalStudioHost");
+    });
+
+    it("parses without metadata.initialTemplate", () => {
+      const { initialTemplate: _initialTemplate, ...rest } = BASE.metadata;
+      const project = parseProject({ ...BASE, metadata: rest });
+      expect(project.metadata).not.toHaveProperty("initialTemplate");
+    });
+
+    it("parses without metadata.cliInitializedAt", () => {
+      const { cliInitializedAt: _cliInitializedAt, ...rest } = BASE.metadata;
+      const project = parseProject({ ...BASE, metadata: rest });
+      expect(project.metadata).not.toHaveProperty("cliInitializedAt");
+    });
+  });
+});