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

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,236 @@
+// 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/core-app.ts

@@ -0,0 +1,113 @@
+// eslint-disable-next-line no-restricted-imports
+import type { ApplicationResource as ProtocolApplicationResource } from "@sanity/message-protocol";
+import { z } from "zod";
+
+import { OrganizationId } from "../organizations";
+import {
+  UserApplication,
+  UserApplicationBase,
+  ActiveDeployment,
+} from "./user-application";
+
+const CoreAppUserApplicationManifest = z.object({
+  version: z.string(),
+  icon: z.string().optional(),
+  title: z.string().optional(),
+});
+
+const CoreAppUserApplicationBase = UserApplicationBase.extend({
+  title: z.string(),
+  organizationId: OrganizationId,
+  type: z.literal("coreApp"),
+  manifest: CoreAppUserApplicationManifest.nullable().optional(),
+});
+
+const InternalCoreAppUserApplication = CoreAppUserApplicationBase.extend({
+  urlType: z.literal("internal"),
+  activeDeployment: ActiveDeployment.extend({
+    manifest: CoreAppUserApplicationManifest.nullable().optional(),
+  }),
+});
+
+const ExternalCoreAppUserApplication = CoreAppUserApplicationBase.extend({
+  urlType: z.literal("external"),
+  activeDeployment: z.null(),
+});
+
+/**
+ * Core application schema — validates and brands API
+ * responses from the `/user-applications?appType=coreApp`
+ * endpoint. Uses a discriminated union on `urlType`.
+ * @public
+ */
+const CoreAppUserApplication = z.discriminatedUnion("urlType", [
+  InternalCoreAppUserApplication,
+  ExternalCoreAppUserApplication,
+]);
+
+/**
+ * @public
+ */
+export type CoreAppUserApplication = z.output<typeof CoreAppUserApplication>;
+
+/**
+ * Validates and parses a raw API response into a branded
+ * CoreAppUserApplicationData.
+ * @public
+ */
+export function parseCoreApplication(data: unknown): CoreAppUserApplication {
+  return CoreAppUserApplication.parse(data);
+}
+
+/**
+ * @internal
+ */
+export class CoreAppApplication extends UserApplication<
+  CoreAppUserApplication,
+  "coreApp",
+  ProtocolApplicationResource
+> {
+  readonly activeDeployment: CoreAppUserApplication["activeDeployment"];
+
+  constructor(application: CoreAppUserApplication) {
+    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 CoreAppUserApplication>(
+    attr: TKey,
+  ): CoreAppUserApplication[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(),
+    } as ProtocolApplicationResource;
+  }
+}

package/src/core/user-applications/studios/index.ts

@@ -0,0 +1,3 @@
+export * from "./schemas";
+export * from "./studio";
+export * from "./workspace";

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

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

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

@@ -0,0 +1,106 @@
+import { z } from "zod";
+
+import { ProjectId } from "../../projects";
+import { ActiveDeployment, UserApplicationBase } from "../user-application";
+
+const Workspace = z.object({
+  name: z.string(),
+  title: z.string(),
+  subtitle: z.string().optional(),
+  basePath: z.string(),
+  projectId: ProjectId,
+  dataset: z.string().optional(),
+  icon: z.string().nullable().optional(),
+});
+
+/**
+ * @public
+ */
+export type Workspace = z.output<typeof Workspace>;
+
+const ServerManifest = z.object({
+  buildId: z.string().optional(),
+  bundleVersion: z.string().optional(),
+  version: z.string().optional(),
+  workspaces: z
+    .array(
+      Workspace.extend({
+        dataset: z.string(),
+        schemaDescriptorId: z.string(),
+      }),
+    )
+    .optional(),
+});
+
+/**
+ * @public
+ */
+export const ClientManifest = z.object({
+  version: z.number(),
+  createdAt: z.string(),
+  studioVersion: z.string().optional(),
+  workspaces: z.array(
+    Workspace.extend({
+      schema: z.string(),
+      tools: z.string().optional(),
+    }),
+  ),
+});
+
+const StudioUserApplicationBase = UserApplicationBase.extend({
+  title: z.string().nullable(),
+  projectId: ProjectId,
+  type: z.literal("studio"),
+  manifest: ClientManifest.nullable(),
+  manifestData: z.object({ value: ClientManifest }).nullable(),
+  autoUpdatingVersion: z.string().nullable(),
+  config: z.object({
+    "live-manifest": z
+      .object({
+        createdAt: z.string(),
+        updatedAt: z.string(),
+        updatedBy: z.string(),
+        value: ServerManifest,
+      })
+      .optional(),
+  }),
+});
+
+const InternalStudioUserApplication = StudioUserApplicationBase.extend({
+  urlType: z.literal("internal"),
+  activeDeployment: ActiveDeployment.extend({
+    manifest: ServerManifest.nullable(),
+  }),
+});
+
+const ExternalStudioUserApplication = StudioUserApplicationBase.extend({
+  urlType: z.literal("external"),
+  activeDeployment: z.null(),
+});
+
+/**
+ * Studio user application schema — validates and brands API
+ * responses from the `/user-applications?appType=studio`
+ * endpoint. Uses a discriminated union on `urlType`.
+ * @public
+ */
+export const StudioUserApplication = z.discriminatedUnion("urlType", [
+  InternalStudioUserApplication,
+  ExternalStudioUserApplication,
+]);
+
+/**
+ * @public
+ */
+export type StudioUserApplication = z.output<typeof StudioUserApplication>;
+
+/**
+ * Validates and parses a raw API response into a branded
+ * StudioUserApplication.
+ * @public
+ */
+export function parseStudioUserApplication(
+  data: unknown,
+): StudioUserApplication {
+  return StudioUserApplication.parse(data);
+}