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

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);
+}

package/src/core/user-applications/{studio.ts → studios/studio.ts}

@@ -1,82 +1,52 @@
-import type {
-  StudioApplication as StudioApplicationData,
-  // eslint-disable-next-line no-restricted-imports
-  StudioResource as ProtocolStudioResource,
-  WorkspaceManifest,
-} from "@sanity/message-protocol";
 import type { SemVer } from "semver";
 import { coerce, gt, gte, lt, rsort, valid } from "semver";
-import { z } from "zod";
 
-import { AbstractApplication } from "../applications/application";
+import { type Project } from "../../projects";
+import { UserApplication } from "../user-application";
 import {
-  brandProjectId,
-  ProjectId as ProjectIdSchema,
-  type Project,
-  type ProjectId,
-} from "../projects";
-import { joinUrlPaths, normalizePath } from "../shared/urls";
-import { type UserApplicationId } from "./user-application";
-import { UserApplication } from "./user-application";
-
-const WORKSPACE_MANIFEST_SCHEMA = z.object({
-  name: z.string(),
-  title: z.string(),
-  subtitle: z.string().nullable().optional(),
-  basePath: z.string(),
-  projectId: ProjectIdSchema,
-  dataset: z.string(),
-  icon: z.string().optional().nullable(),
-  schema: z.string(),
-  tools: z.string().optional(),
-});
-
-const STUDIO_MANIFEST_SCHEMA = z
-  .object({
-    // data from manifest
-    version: z.number(),
-    createdAt: z.string(),
-    studioVersion: z.string().nullable().optional(),
-    // data from workspace object
-    workspaces: z.array(WORKSPACE_MANIFEST_SCHEMA),
-  })
-  .superRefine((data, ctx) => {
-    if (!data.version) {
-      ctx.addIssue({
-        code: "invalid_type",
-        message: "Manifest version is too old",
-        expected: "number",
-      });
-    }
+  type Workspace,
+  type StudioUserApplication,
+  ClientManifest as ClientManifestSchema,
+} from "./schemas";
+import { StudioWorkspace } from "./workspace";
+
+const ClientManifest = ClientManifestSchema.superRefine((data, ctx) => {
+  if (!data.version) {
+    ctx.addIssue({
+      code: "invalid_type",
+      message: "Manifest version is too old",
+      expected: "number",
+    });
+  }
 
-    if (data.version < 2) {
-      ctx.addIssue({
-        code: "invalid_value",
-        message: "Manifest version is too old",
-        values: [2, 3],
-      });
-    }
+  if (data.version < 2) {
+    ctx.addIssue({
+      code: "invalid_value",
+      message: "Manifest version is too old",
+      values: [2, 3],
+    });
+  }
 
-    if (data.version >= 3 && !data.studioVersion) {
-      ctx.addIssue({
-        code: "invalid_type",
-        message: "Manifest version 3 or higher requires a `studioVersion`",
-        expected: "string",
-      });
-    }
-  });
+  if (data.version >= 3 && !data.studioVersion) {
+    ctx.addIssue({
+      code: "invalid_type",
+      message: "Manifest version 3 or higher requires a `studioVersion`",
+      expected: "string",
+    });
+  }
+});
 
 const DEFAULT_WORKSPACE_DATA = {
   name: "default",
   title: "Default",
   basePath: "/",
-} as const satisfies Partial<Workspace>;
+} as const satisfies Omit<Workspace, "projectId">;
 
 /**
  * @internal
  */
 export class StudioApplication extends UserApplication<
-  StudioApplicationData,
+  StudioUserApplication,
   "studio",
   never
 > {
@@ -88,6 +58,14 @@ export class StudioApplication extends UserApplication<
 
   readonly project: Project<false, false>;
 
+  /**
+   * The projects actually referenced by this studio — the application's own
+   * project plus any project used by a workspace. Preserved so the instance
+   * can be re-constructed (e.g. by dock wrappers) without having to thread
+   * the full organization project list through again.
+   */
+  readonly projects: Project<false, false>[];
+
   /**
    * @param application - The studio application to create a list of workspaces for
    * @param projects - The projects available in the organization. It's not enough to just pass
@@ -95,7 +73,7 @@ export class StudioApplication extends UserApplication<
    * The workspaces may have different projects completely.
    */
   constructor(
-    application: StudioApplicationData,
+    application: StudioUserApplication,
     projects: Project<false, false>[],
   ) {
     super(application, "studio");
@@ -113,7 +91,7 @@ export class StudioApplication extends UserApplication<
        * this could potentially crash the app. Instead we log a warning and return an empty array.
        */
       try {
-        workspaces = STUDIO_MANIFEST_SCHEMA.parse(
+        workspaces = ClientManifest.parse(
           application.manifestData?.value,
         ).workspaces;
       } catch (error) {
@@ -148,10 +126,7 @@ export class StudioApplication extends UserApplication<
         Array.isArray(serverManifestWorkspaces) &&
         serverManifestWorkspaces.length
       ) {
-        workspaces = serverManifestWorkspaces.map((w) => ({
-          ...w,
-          projectId: brandProjectId(w.projectId),
-        }));
+        workspaces = serverManifestWorkspaces;
       }
     }
 
@@ -172,8 +147,7 @@ export class StudioApplication extends UserApplication<
       return acc;
     }, new Map<Workspace, Project<false, false>>());
 
-    const brandedProjectId = brandProjectId(application.projectId);
-    const project = projects.find((p) => p.id === brandedProjectId);
+    const project = projects.find((p) => p.id === application.projectId);
 
     if (!project) {
       throw new Error(`Project not found for application ${application.id}`);
@@ -186,7 +160,7 @@ export class StudioApplication extends UserApplication<
       workspacesWithProjectsMap.set(
         {
           ...DEFAULT_WORKSPACE_DATA,
-          projectId: brandedProjectId,
+          projectId: application.projectId,
         } satisfies Workspace,
         project,
       );
@@ -210,6 +184,14 @@ export class StudioApplication extends UserApplication<
     );
 
     this.project = project;
+
+    // Collect only the projects actually referenced by this studio — the
+    // application's own project plus any project used by a workspace.
+    const usedProjects = new Set<Project<false, false>>([project]);
+    for (const workspace of this.workspaces) {
+      usedProjects.add(workspace.project);
+    }
+    this.projects = Array.from(usedProjects);
   }
 
   get href() {
@@ -236,9 +218,9 @@ export class StudioApplication extends UserApplication<
     return new URL(this.url).hostname;
   }
 
-  get<TKey extends keyof StudioApplicationData>(
+  get<TKey extends keyof StudioUserApplication>(
     attr: TKey,
-  ): StudioApplicationData[TKey] {
+  ): StudioUserApplication[TKey] {
     if (!(attr in this.application)) {
       throw new Error(
         `Attribute ${attr.toString()} does not exist on studio ${this.application.id}`,
@@ -514,143 +496,3 @@ type StudioIssues = Array<{
   id: StudioDashboardIssue;
   version?: string;
 }>;
-
-type Workspace = Omit<WorkspaceManifest, "dataset" | "schema" | "projectId"> & {
-  projectId: ProjectId;
-  dataset?: string;
-  schema?: string;
-};
-
-/**
- * @internal
- */
-export class StudioWorkspace extends AbstractApplication<
-  "workspace",
-  ProtocolStudioResource
-> {
-  /**
-   * Workspaces always belong to a studio application.
-   * They do not exist on their own & therefore can access
-   * information about the studio they're in via this property.
-   */
-  private readonly studioApplication: StudioApplication;
-  private readonly workspace: Workspace;
-  readonly project: Project<false, false>;
-  private readonly isDefaultWorkspace: boolean;
-
-  constructor(
-    studioApplication: StudioApplication,
-    workspace: Workspace,
-    project: Project<false, false>,
-    isDefaultWorkspace: boolean,
-  ) {
-    super("workspace");
-
-    this.studioApplication = studioApplication;
-    this.workspace = workspace;
-    this.project = project;
-    this.isDefaultWorkspace = isDefaultWorkspace;
-  }
-
-  /**
-   * The studio application that this workspace belongs to.
-   */
-  get studio() {
-    return this.studioApplication;
-  }
-
-  get id() {
-    return StudioWorkspace.makeId(this.studio.id, this.workspace.name);
-  }
-
-  get href() {
-    return joinUrlPaths(this.studio.href, this.workspace.name);
-  }
-
-  get title() {
-    /**
-     * If there's no manifest we will have created a single workspace for the application.
-     * In this circumstance we won't have a meaningful title, so instead we use the hostname of the appHost.
-     */
-    if (this.isDefaultWorkspace) {
-      return this.project.displayName;
-    }
-
-    return this.workspace.title;
-  }
-
-  get subtitle() {
-    if (this.isDefaultWorkspace) {
-      const isValidAppHost = URL.canParse(this.studio.get("appHost"));
-      const url = isValidAppHost
-        ? new URL(this.studio.get("appHost"))
-        : this.studio.url;
-
-      return url.hostname;
-    }
-
-    return this.get("subtitle");
-  }
-
-  get<TKey extends Exclude<keyof Workspace, "id" | "icon" | "title">>(
-    attr: TKey,
-  ): Workspace[TKey] {
-    return this.workspace[attr];
-  }
-
-  /**
-   * With comlink, studio-applications were not considered applications at all, only workspaces. This is partially why
-   * we create default workspaces when the application has no manifest or the manifest has no workspaces.
-   *
-   * Thereby, to create it we depend on a lot of information from the parent application even if it's duplicated across
-   * different workspaces.
-   */
-  toProtocolResource(): ProtocolStudioResource {
-    return {
-      ...this.workspace,
-      type: "studio",
-      userApplicationId: this.studio.id,
-      activeDeployment: this.studio.get("activeDeployment"),
-      autoUpdatingVersion: this.studio.get("autoUpdatingVersion"),
-      dashboardStatus: this.studio.get("dashboardStatus"),
-      url: this.studio.url.toString(),
-      href: this.href,
-      id: this.id,
-      hasManifest: true,
-      hasSchema: Boolean(this.workspace.schema),
-      manifest: this.studio.get("manifestData")?.value ?? null,
-      updatedAt: this.studio.get("updatedAt"),
-      version: this.studio.get("activeDeployment")?.version,
-      urlType: this.studio.get("urlType"),
-      config: this.studio.get("config"),
-    } satisfies ProtocolStudioResource;
-  }
-
-  /**
-   * @returns the URL to the workspace of a studio application.
-   */
-  get url(): URL {
-    const studioUrl = new URL(this.studio.url);
-    const normalizedUrlPath = normalizePath(studioUrl.pathname);
-
-    let finalBasePath = normalizePath(this.get("basePath"));
-
-    // the appHost may already contain the basepath for externally hosted studios
-    // or embedded studios, so we deduplicate the segments
-    if (finalBasePath.startsWith(normalizedUrlPath)) {
-      finalBasePath = finalBasePath.slice(normalizedUrlPath.length);
-    }
-
-    studioUrl.pathname = joinUrlPaths(normalizedUrlPath, finalBasePath);
-
-    return studioUrl;
-  }
-
-  static makeId(applicationId: UserApplicationId, workspaceName: string) {
-    return `${applicationId}-${workspaceName}`;
-  }
-
-  static splitId(id: string): [string, string] {
-    return id.split(new RegExp(/-(.*)/)).slice(0, 2) as [string, string];
-  }
-}

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

@@ -0,0 +1,143 @@
+import type { StudioResource as ProtocolStudioResource } from "@sanity/message-protocol";
+
+import { AbstractApplication } from "../../applications/application";
+import type { Project } from "../../projects";
+import { joinUrlPaths, normalizePath } from "../../shared/urls";
+import type { UserApplicationId } from "../user-application";
+import type { Workspace } from "./schemas";
+import type { StudioApplication } from "./studio";
+
+/**
+ * @internal
+ */
+export class StudioWorkspace extends AbstractApplication<
+  "workspace",
+  ProtocolStudioResource
+> {
+  /**
+   * Workspaces always belong to a studio application.
+   * They do not exist on their own & therefore can access
+   * information about the studio they're in via this property.
+   */
+  private readonly studioApplication: StudioApplication;
+  private readonly workspace: Workspace;
+  readonly project: Project<false, false>;
+  private readonly isDefaultWorkspace: boolean;
+
+  constructor(
+    studioApplication: StudioApplication,
+    workspace: Workspace,
+    project: Project<false, false>,
+    isDefaultWorkspace: boolean,
+  ) {
+    super("workspace");
+
+    this.studioApplication = studioApplication;
+    this.workspace = workspace;
+    this.project = project;
+    this.isDefaultWorkspace = isDefaultWorkspace;
+  }
+
+  /**
+   * The studio application that this workspace belongs to.
+   */
+  get studio() {
+    return this.studioApplication;
+  }
+
+  get id() {
+    return StudioWorkspace.makeId(this.studio.id, this.workspace.name);
+  }
+
+  get href() {
+    return joinUrlPaths(this.studio.href, this.workspace.name);
+  }
+
+  get title() {
+    /**
+     * If there's no manifest we will have created a single workspace for the application.
+     * In this circumstance we won't have a meaningful title, so instead we use the hostname of the appHost.
+     */
+    if (this.isDefaultWorkspace) {
+      return this.project.displayName;
+    }
+
+    return this.workspace.title;
+  }
+
+  get subtitle() {
+    if (this.isDefaultWorkspace) {
+      const isValidAppHost = URL.canParse(this.studio.get("appHost"));
+      const url = isValidAppHost
+        ? new URL(this.studio.get("appHost"))
+        : this.studio.url;
+
+      return url.hostname;
+    }
+
+    return this.get("subtitle");
+  }
+
+  get<TKey extends Exclude<keyof Workspace, "id" | "icon" | "title">>(
+    attr: TKey,
+  ): Workspace[TKey] {
+    return this.workspace[attr];
+  }
+
+  /**
+   * With comlink, studio-applications were not considered applications at all, only workspaces. This is partially why
+   * we create default workspaces when the application has no manifest or the manifest has no workspaces.
+   *
+   * Thereby, to create it we depend on a lot of information from the parent application even if it's duplicated across
+   * different workspaces.
+   */
+  toProtocolResource(): ProtocolStudioResource {
+    return {
+      ...this.workspace,
+      type: "studio",
+      userApplicationId: this.studio.id,
+      activeDeployment: this.studio.get("activeDeployment"),
+      autoUpdatingVersion: this.studio.get("autoUpdatingVersion"),
+      dashboardStatus: this.studio.get("dashboardStatus"),
+      url: this.studio.url.toString(),
+      href: this.href,
+      id: this.id,
+      hasManifest: true,
+      hasSchema: Boolean("schema" in this.workspace && this.workspace.schema),
+      manifest: (this.studio.get("manifestData")?.value ??
+        null) as ProtocolStudioResource["manifest"],
+      updatedAt: this.studio.get("updatedAt"),
+      version: this.studio.get("activeDeployment")?.version,
+      urlType: this.studio.get("urlType"),
+      config: this.studio.get("config"),
+    } satisfies ProtocolStudioResource;
+  }
+
+  /**
+   * @returns the URL to the workspace of a studio application.
+   */
+  get url(): URL {
+    const studioUrl = new URL(this.studio.url);
+    const normalizedUrlPath = normalizePath(studioUrl.pathname);
+
+    let finalBasePath = normalizePath(this.get("basePath"));
+
+    // the appHost may already contain the basepath for externally hosted studios
+    // or embedded studios, so we deduplicate the segments
+    if (finalBasePath.startsWith(normalizedUrlPath)) {
+      finalBasePath = finalBasePath.slice(normalizedUrlPath.length);
+    }
+
+    studioUrl.pathname = joinUrlPaths(normalizedUrlPath, finalBasePath);
+
+    return studioUrl;
+  }
+
+  static makeId(applicationId: UserApplicationId, workspaceName: string) {
+    return `${applicationId}-${workspaceName}`;
+  }
+
+  static splitId(id: string): [string, string] {
+    return id.split(new RegExp(/-(.*)/)).slice(0, 2) as [string, string];
+  }
+}

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

@@ -1,7 +1,5 @@
-import type {
-  Resource as ProtocolResource,
-  UserApplication as UserApplicationData,
-} from "@sanity/message-protocol";
+// eslint-disable-next-line no-restricted-imports
+import type { Resource as ProtocolResource } from "@sanity/message-protocol";
 import { z } from "zod";
 
 import {
@@ -32,11 +30,44 @@ export function brandUserApplicationId(id: string): UserApplicationId {
   return UserApplicationId.parse(id);
 }
 
+/**
+ * @public
+ */
+export const UserApplicationBase = z.object({
+  id: UserApplicationId,
+  appHost: z.string(),
+  urlType: z.enum(["internal", "external"]),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  dashboardStatus: z.enum(["default", "disabled"]),
+});
+
+/**
+ * @public
+ */
+export type UserApplicationBase = z.output<typeof UserApplicationBase>;
+
+/**
+ * @public
+ */
+export const ActiveDeployment = z.object({
+  id: z.string(),
+  version: z.string(),
+  isActiveDeployment: z.boolean(),
+  userApplicationId: z.string(),
+  isAutoUpdating: z.boolean(),
+  size: z.number(),
+  deployedAt: z.string(),
+  deployedBy: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
 /**
  * @internal
  */
 export abstract class UserApplication<
-  TUserApplication extends UserApplicationData,
+  TUserApplication extends UserApplicationBase,
   TType extends Extract<AbstractApplicationType, "coreApp" | "studio">,
   TProtocolResource extends ProtocolResource = Extract<
     ProtocolResource,