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

package/src/core/canvases.test.ts

@@ -1,38 +0,0 @@
-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/log/index.test.ts

@@ -1,133 +0,0 @@
-import {
-  type MockInstance,
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  vi,
-} from "vitest";
-
-import { createLogger } from ".";
-
-describe("createLogger", () => {
-  let error: MockInstance;
-  let warn: MockInstance;
-  let info: MockInstance;
-  let debug: MockInstance;
-
-  beforeEach(() => {
-    error = vi.spyOn(console, "error").mockImplementation(() => undefined);
-    warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-    info = vi.spyOn(console, "info").mockImplementation(() => undefined);
-    debug = vi.spyOn(console, "debug").mockImplementation(() => undefined);
-  });
-
-  afterEach(() => vi.restoreAllMocks());
-
-  it("'none': logs nothing", () => {
-    const logger = createLogger({ logLevel: "none" });
-
-    logger.error("e");
-    logger.warn("w");
-    logger.info("i");
-    logger.debug("d");
-
-    expect(error).not.toHaveBeenCalled();
-    expect(warn).not.toHaveBeenCalled();
-    expect(info).not.toHaveBeenCalled();
-    expect(debug).not.toHaveBeenCalled();
-  });
-
-  it("'error': logs only error", () => {
-    const logger = createLogger({ logLevel: "error" });
-
-    logger.error("e");
-    logger.warn("w");
-    logger.info("i");
-    logger.debug("d");
-
-    expect(error).toHaveBeenCalledOnce();
-    expect(warn).not.toHaveBeenCalled();
-    expect(info).not.toHaveBeenCalled();
-    expect(debug).not.toHaveBeenCalled();
-  });
-
-  it("'warn': logs error and warn", () => {
-    const logger = createLogger({ logLevel: "warn" });
-
-    logger.error("e");
-    logger.warn("w");
-    logger.info("i");
-    logger.debug("d");
-
-    expect(error).toHaveBeenCalledOnce();
-    expect(warn).toHaveBeenCalledOnce();
-    expect(info).not.toHaveBeenCalled();
-    expect(debug).not.toHaveBeenCalled();
-  });
-
-  it("'info' (default): logs error, warn, and info", () => {
-    const logger = createLogger();
-
-    logger.error("e");
-    logger.warn("w");
-    logger.info("i");
-    logger.debug("d");
-
-    expect(error).toHaveBeenCalledOnce();
-    expect(warn).toHaveBeenCalledOnce();
-    expect(info).toHaveBeenCalledOnce();
-    expect(debug).not.toHaveBeenCalled();
-  });
-
-  it("'debug': logs everything", () => {
-    const logger = createLogger({ logLevel: "debug" });
-
-    logger.error("e");
-    logger.warn("w");
-    logger.info("i");
-    logger.debug("d");
-
-    expect(error).toHaveBeenCalledOnce();
-    expect(warn).toHaveBeenCalledOnce();
-    expect(info).toHaveBeenCalledOnce();
-    expect(debug).toHaveBeenCalledOnce();
-  });
-
-  it("prepends [namespace] to all messages", () => {
-    const logger = createLogger({ namespace: "myns", logLevel: "debug" });
-
-    logger.error("msg");
-    logger.warn("msg");
-    logger.info("msg");
-    logger.debug("msg");
-
-    expect(error).toHaveBeenCalledWith("[myns]", "msg");
-    expect(warn).toHaveBeenCalledWith("[myns]", "msg");
-    expect(info).toHaveBeenCalledWith("[myns]", "msg");
-    expect(debug).toHaveBeenCalledWith("[myns]", "msg");
-  });
-
-  it("passes context as a third argument when provided", () => {
-    const logger = createLogger({ namespace: "ns", logLevel: "debug" });
-    const ctx = { requestId: "123" };
-    logger.error("msg", ctx);
-    expect(error).toHaveBeenCalledWith("[ns]", "msg", ctx);
-  });
-
-  it("merges base context with call-site context", () => {
-    const logger = createLogger({
-      namespace: "ns",
-      context: { service: "workbench" },
-      logLevel: "debug",
-    });
-
-    logger.debug("msg", { requestId: "42" });
-
-    expect(debug).toHaveBeenCalledWith("[ns]", "msg", {
-      service: "workbench",
-      requestId: "42",
-    });
-  });
-});

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

@@ -1,38 +0,0 @@
-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/organizations.test.ts

@@ -1,134 +0,0 @@
-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/projects.test.ts

@@ -1,248 +0,0 @@
-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");
-    });
-  });
-});