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

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.test.ts

@@ -1,18 +1,17 @@
-import type {
-  ApplicationResource as ProtocolApplicationResource,
-  CoreApplication,
-} from "@sanity/message-protocol";
+// eslint-disable-next-line no-restricted-imports
+import type { ApplicationResource as ProtocolApplicationResource } from "@sanity/message-protocol";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 import { APPLICATION_DATA } from "../__tests__/__fixtures__";
+import type { CoreAppUserApplication } from "./core-app";
 import { UserApplication as AbstractUserApplication } from "./user-application";
 
 class UserApplication extends AbstractUserApplication<
-  CoreApplication,
+  CoreAppUserApplication,
   "coreApp",
   ProtocolApplicationResource
 > {
-  constructor(application: CoreApplication) {
+  constructor(application: CoreAppUserApplication) {
     super(application, "coreApp");
   }
 
@@ -37,11 +36,11 @@ class UserApplication extends AbstractUserApplication<
   }
 }
 
-const setup = (overrides?: Partial<CoreApplication>) =>
+const setup = (overrides?: Partial<CoreAppUserApplication>) =>
   new UserApplication({
     ...APPLICATION_DATA,
     ...overrides,
-  } as CoreApplication);
+  } as CoreAppUserApplication);
 
 describe("UserApplication", () => {
   afterEach(() => {

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,