@sanity/workbench 0.1.0-alpha.1 → 0.1.0-alpha.11

package/src/core/shared/urls.ts

@@ -0,0 +1,129 @@
+/**
+ * Joins multiple path segments into a single path string.
+ * Handles null, undefined, and URL objects gracefully.
+ *
+ * @public
+ * @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.ts

@@ -0,0 +1,131 @@
+// 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";
+
+/**
+ * @public
+ */
+export const CoreAppUserApplicationManifest = z.object({
+  version: z.string(),
+  icon: z.string().optional(),
+  title: z.string().optional(),
+});
+
+/**
+ * @public
+ */
+export type CoreAppUserApplicationManifest = z.output<
+  typeof CoreAppUserApplicationManifest
+>;
+
+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(),
+  }).nullable(),
+});
+
+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);
+}
+
+/**
+ * @public
+ */
+export class CoreAppApplication extends UserApplication<
+  CoreAppUserApplication,
+  "coreApp",
+  ProtocolApplicationResource
+> {
+  readonly activeDeployment: CoreAppUserApplication["activeDeployment"];
+
+  constructor(
+    application: CoreAppUserApplication,
+    options: {
+      isLocal?: boolean;
+      remoteApplication?: CoreAppApplication | null;
+    } = {},
+  ) {
+    super(application, "coreApp", options);
+
+    this.activeDeployment = application.activeDeployment;
+  }
+
+  get href() {
+    return this.isLocal
+      ? `/local/${this.id}`
+      : `/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.ts

@@ -0,0 +1,111 @@
+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(),
+    }),
+  ),
+});
+
+/**
+ * @public
+ */
+export type ClientManifest = z.output<typeof ClientManifest>;
+
+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);
+}