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

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

@@ -0,0 +1,656 @@
+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 {
+  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",
+      });
+    }
+
+    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",
+      });
+    }
+  });
+
+const DEFAULT_WORKSPACE_DATA = {
+  name: "default",
+  title: "Default",
+  basePath: "/",
+} as const satisfies Partial<Workspace>;
+
+/**
+ * @internal
+ */
+export class StudioApplication extends UserApplication<
+  StudioApplicationData,
+  "studio",
+  never
+> {
+  /**
+   * Returns a list of studio workspaces based on the application manifest.
+   * If there is no manifest, or alternatively it is not valid, then we create a default workspace.
+   */
+  readonly workspaces: readonly StudioWorkspace[] = [];
+
+  readonly project: 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
+   * the project that associates with the application because that is the project the app is deployed in relation to.
+   * The workspaces may have different projects completely.
+   */
+  constructor(
+    application: StudioApplicationData,
+    projects: Project<false, false>[],
+  ) {
+    super(application, "studio");
+
+    /**
+     * If the application has a manifest, then we validate it and create
+     * a workspace for each manifest entry. Otherwise, we will create a "default"
+     * workspace which is pretty much identical to when a user has a single workspace
+     * studio application using the term "default" in places.
+     */
+    let workspaces: Workspace[] = [];
+    if (this.hasManifest) {
+      /**
+       * If the workspaces fail to parse we dont want to throw an error because
+       * this could potentially crash the app. Instead we log a warning and return an empty array.
+       */
+      try {
+        workspaces = STUDIO_MANIFEST_SCHEMA.parse(
+          application.manifestData?.value,
+        ).workspaces;
+      } catch (error) {
+        console.warn(
+          `Failed to parse manifest for application ${application.id}`,
+          error,
+        );
+      }
+    }
+
+    if (workspaces.length === 0) {
+      /**
+       * If the user application does not have a valid manifest or no workspaces,
+       * we attempt to get the manifest from the server-side maninfest first and then
+       * fall back to the live-manifest.
+       *
+       * In the future this should happen even before checking the traditional manifest,
+       * but for now we keep the current order to not introduce breaking changes.
+       *
+       * The live manifest is inherintly less reliable as it depends on which user has
+       * uploaded it, which is why this is wrapped in a feature flag for now.
+       */
+      const deploymentManifest = application.activeDeployment?.manifest;
+      // const liveManifest = growthbook.isOn('dashboard-use-live-manifest')
+      //   ? application.config['live-manifest']?.value
+      //   : null
+
+      const serverManifest = deploymentManifest; /*?? liveManifest*/
+      const serverManifestWorkspaces = serverManifest?.workspaces;
+
+      if (
+        Array.isArray(serverManifestWorkspaces) &&
+        serverManifestWorkspaces.length
+      ) {
+        workspaces = serverManifestWorkspaces.map((w) => ({
+          ...w,
+          projectId: brandProjectId(w.projectId),
+        }));
+      }
+    }
+
+    /**
+     * Filter all the workspaces that have a project the user does not have access to
+     */
+    const workspacesWithProjectsMap = workspaces.reduce((acc, workspace) => {
+      const project = projects.find((p) => p.id === workspace.projectId);
+
+      if (project) {
+        acc.set(workspace, project);
+      } else {
+        console.warn(
+          `Project not found for application ${application.id} and workspace ${workspace.name}. This workspace has been omitted.`,
+        );
+      }
+
+      return acc;
+    }, new Map<Workspace, Project<false, false>>());
+
+    const brandedProjectId = brandProjectId(application.projectId);
+    const project = projects.find((p) => p.id === brandedProjectId);
+
+    if (!project) {
+      throw new Error(`Project not found for application ${application.id}`);
+    }
+
+    if (workspacesWithProjectsMap.size === 0) {
+      /**
+       * If there are still no workspaces, we create a default workspace.
+       */
+      workspacesWithProjectsMap.set(
+        {
+          ...DEFAULT_WORKSPACE_DATA,
+          projectId: brandedProjectId,
+        } satisfies Workspace,
+        project,
+      );
+    }
+
+    this.workspaces = Object.freeze(
+      Array.from(workspacesWithProjectsMap.entries()).map(([workspace, p]) => {
+        /**
+         * A workspace is considered the default if the dashboard generated it OR because
+         * the properties match that of the default workspace generated by the studio.
+         * Which is why these values will match because dashboard generates an identical
+         * workspace to the default studio one.
+         */
+        const isDefaultWorkspace =
+          workspace.name === DEFAULT_WORKSPACE_DATA.name &&
+          workspace.basePath === DEFAULT_WORKSPACE_DATA.basePath &&
+          workspace.title === DEFAULT_WORKSPACE_DATA.title;
+
+        return new StudioWorkspace(this, workspace, p, isDefaultWorkspace);
+      }),
+    );
+
+    this.project = project;
+  }
+
+  get href() {
+    return `/studio/${this.application.id}`;
+  }
+
+  get title() {
+    // Get the title from the user application, this has the highest precedence
+    const title = this.get("title");
+    if (title) {
+      return title;
+    }
+
+    // If there are multiple workspaces and the studio is internal, use the project display name
+    if (this.workspaces.length > 1 && this.get("urlType") === "internal") {
+      return this.project.displayName;
+    }
+
+    // Otherwise use the title of the first workspace
+    return this.workspaces[0].title;
+  }
+
+  get subtitle() {
+    return new URL(this.url).hostname;
+  }
+
+  get<TKey extends keyof StudioApplicationData>(
+    attr: TKey,
+  ): StudioApplicationData[TKey] {
+    if (!(attr in this.application)) {
+      throw new Error(
+        `Attribute ${attr.toString()} does not exist on studio ${this.application.id}`,
+      );
+    }
+
+    return this.application[attr];
+  }
+
+  get hasManifest(): boolean {
+    return (
+      typeof this.application.manifestData?.value?.version === "number" &&
+      this.application.manifestData?.value?.version >= 2
+    );
+  }
+
+  get hasSchema(): boolean {
+    // In this case we can not look at `this.workspaces` because it won't contain workspaces the user does
+    // not have access to. The application has a schema, even if the user can't access any of the workspaces,
+    // otherwise it would be displayed as not having a manifest in the setup guide and therefore considered
+    // partially compatible.
+    const workspaces = this.get("manifestData")?.value?.workspaces ?? [];
+
+    if (workspaces.length === 0) {
+      return false;
+    }
+
+    return workspaces.every((w) => Boolean(w.schema));
+  }
+
+  private resolveVersion() {
+    // const growthbook = getGrowthbook()
+
+    let version: string | undefined;
+
+    if (this.get("urlType") === "internal") {
+      version = this.get("activeDeployment")?.version;
+    } else {
+      const manifest = this.get("manifestData")?.value;
+      // The property 'studioVersion' exists only on external studios,
+      // starting from manifest.version 3
+      version =
+        manifest && "studioVersion" in manifest
+          ? manifest.studioVersion
+          : undefined;
+    }
+
+    /**
+     * Self-hosted studios are often not publicly accessible, which means that
+     * Brett often times cannot fetch the manifest to read the version. In this case
+     * we try to read the version from the deployment manifest or 'live-manifest', if it exists, to do
+     * everything we can to determine the version.
+     *
+     * Since the data of the live-maninfest can not be trusted, we also must validate
+     * that the version is a valid semver version before returning it. It always represents
+     * the last known version from when the studio was connected to Sanity's infrastructure,
+     * which might not be the version this studio is currently running (e.g. because the version
+     * has been downgraded).
+     */
+    const deploymentManifest = this.get("activeDeployment")?.manifest;
+    // const liveManifest = growthbook.isOn('dashboard-use-live-manifest')
+    //   ? this.get('config')?.['live-manifest']?.value
+    //   : null
+
+    const serverManifest = deploymentManifest; /*?? liveManifest*/
+    const bundleVersion = serverManifest?.bundleVersion;
+
+    if (bundleVersion && valid(coerce(bundleVersion))) {
+      if (!version || (version && gt(bundleVersion, version))) {
+        version = bundleVersion;
+      }
+    }
+
+    if (!version || !valid(coerce(version))) {
+      return null;
+    }
+
+    return coerce(version);
+  }
+
+  get version() {
+    const version = this.resolveVersion();
+    return version ? version.toString() : null;
+  }
+
+  get compatibilityStatus(): CompatibilityStatus {
+    return StudioApplication.resolveCompatibilityStatus(this);
+  }
+
+  /**
+   * Used to calculate the compatibility status of a given studio application.
+   * Optionally if you've resolved the version elsewhere provide that value to
+   * get the new compatibility status without mutating the application.
+   */
+  static resolveCompatibilityStatus(
+    application: StudioApplication,
+    version: string | null = application.version,
+  ): CompatibilityStatus {
+    if (
+      version === null ||
+      lt(version, StudioApplication.MinimumStudioVersion)
+    ) {
+      return StudioApplication.CompatibilityStatuses.UNKNOWN;
+    }
+
+    if (
+      !application.hasSchema ||
+      !application.hasManifest ||
+      StudioApplication.resolveIssues(application, version).length > 0
+    ) {
+      return StudioApplication.CompatibilityStatuses.PARTIALLY_COMPATIBLE;
+    }
+
+    return StudioApplication.CompatibilityStatuses.FULLY_COMPATIBLE;
+  }
+
+  get isAutoRedirecting(): boolean {
+    return StudioApplication.resolveIsAutoRedirecting(this);
+  }
+
+  /**
+   * Mirrors the `isRedirectable` function from Saison defined in
+   * https://github.com/sanity-io/saison/blob/83556405d23e07f6d3a71c76249c67e33fe1101f/src/utils/applications.ts
+   *
+   * Returns whether a studio application is auto-redirecting, meaning it can only be accessed in the context of
+   * Dashboard.
+   */
+  static resolveIsAutoRedirecting(
+    application: StudioApplication,
+    versionArg = application.version,
+  ) {
+    let version: string | SemVer | null = versionArg;
+
+    if (application.get("urlType") === "external" || !version) {
+      return false;
+    }
+
+    if (!application.get("activeDeployment")?.isAutoUpdating) {
+      // If the studio is not auto-updating, we need to check if the version supports
+      // workspace switcher (3.92.0+) otherwise it would not be redirected.
+      return gt(version, "3.92.0");
+    }
+
+    const autoUpdatingVersion = application.get("autoUpdatingVersion");
+
+    if (autoUpdatingVersion) {
+      if (["next", "stable", "latest"].includes(autoUpdatingVersion)) {
+        return true;
+      }
+
+      const autoUpdatingVersionPinnedVersion = coerce(autoUpdatingVersion);
+
+      if (autoUpdatingVersionPinnedVersion) {
+        version = autoUpdatingVersionPinnedVersion;
+      }
+    }
+
+    return gt(version, StudioApplication.MinimumStudioVersion);
+  }
+
+  /**
+   * Returns a list of issues that prevent the studio from functioning properly in the Dashboard.
+   * This static value depends on the version of the studio that comes from the `activeDeployment` property.
+   * As such, if the studio is auto-updating, this list will be incorrect & instead you should use
+   * the static method `resolveIssues` to get the correct issues by passing the resolved version.
+   */
+  get issues(): StudioIssues {
+    return StudioApplication.resolveIssues(this);
+  }
+
+  static resolveIssues(
+    application: StudioApplication,
+    version: string | null = application.version,
+  ): StudioIssues {
+    const issues: StudioIssues = StudioApplication.Features.filter(
+      (feature) => {
+        return !application.isFeatureSupported(feature.id, version);
+      },
+    );
+
+    if (!application.hasManifest) {
+      issues.push({
+        id: StudioApplication.StudioIssues.ISSUE_MANIFEST,
+      });
+    }
+
+    return issues;
+  }
+
+  protected isFeatureSupported(
+    feature: StudioDashboardIssue,
+    version = this.version,
+  ) {
+    const featureVersion = StudioApplication.Features.find(
+      (_) => _.id === feature,
+    )?.version;
+
+    if (!featureVersion || !version) {
+      return false;
+    }
+
+    return gte(version, featureVersion);
+  }
+
+  toProtocolResource(): never {
+    throw new Error(
+      "Studio application resources cannot be converted to protocol resources",
+    );
+  }
+
+  static CompatibilityStatuses = {
+    UNKNOWN: "unknown",
+    PARTIALLY_COMPATIBLE: "partially-compatible",
+    FULLY_COMPATIBLE: "fully-compatible",
+  } as const;
+
+  static StudioIssues = {
+    ISSUE_ACTIVITY: "ACTIVITY",
+    ISSUE_AGENT: "AGENT",
+    ISSUE_FAVORITES: "FAVORITES",
+    ISSUE_URL_SYNCING: "URL_SYNCING",
+    ISSUE_UI_ADJUSTMENT: "UI_ADJUSTMENT",
+    ISSUE_CONTENT_MAPPING: "CONTENT_MAPPING",
+    ISSUE_LOGIN: "LOGIN",
+    ISSUE_MANIFEST: "MANIFEST",
+  } as const;
+
+  static Features = [
+    {
+      id: StudioApplication.StudioIssues.ISSUE_AGENT,
+      version: "5.1.0",
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_FAVORITES,
+      version: "3.88.1",
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_ACTIVITY,
+      version: "3.88.1",
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_URL_SYNCING,
+      version: "3.75.0",
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_UI_ADJUSTMENT,
+      version: "3.78.1",
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_CONTENT_MAPPING,
+      version: "3.68.0",
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_LOGIN,
+      version: "2.28.0",
+    },
+  ] satisfies StudioIssues;
+
+  static MinimumStudioVersion = "2.28.0" as const;
+
+  static MinimumStudioVersionWithNoIssues = rsort(
+    StudioApplication.Features.map((feature) => feature.version),
+  ).at(0);
+}
+
+type CompatibilityStatus =
+  (typeof StudioApplication.CompatibilityStatuses)[keyof typeof StudioApplication.CompatibilityStatuses];
+
+type StudioDashboardIssue =
+  (typeof StudioApplication.StudioIssues)[keyof typeof StudioApplication.StudioIssues];
+
+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];
+  }
+}