@sanity/workbench 0.1.0-alpha.2 → 0.1.0-alpha.21

package/src/core/organizations.ts

@@ -0,0 +1,115 @@
+import { z } from "zod";
+
+/**
+ * Organization ID schema, branded for type safety.
+ * @public
+ */
+export const OrganizationId = z.string().nonempty().brand("OrganizationId");
+
+/**
+ * Organization ID type, branded for type safety.
+ * @public
+ */
+export type OrganizationId = z.output<typeof OrganizationId>;
+
+/**
+ * Validates and brands a string as an OrganizationId.
+ * @public
+ */
+export function brandOrganizationId(id: string): OrganizationId {
+  return OrganizationId.parse(id);
+}
+
+const OrganizationMember = z.object({
+  sanityUserId: z.string(),
+  isCurrentUser: z.boolean(),
+  user: z.object({
+    id: z.string(),
+    displayName: z.string(),
+    familyName: z.string(),
+    givenName: z.string(),
+    middleName: z.string().nullable(),
+    imageUrl: z.string().nullable(),
+    email: z.string(),
+    loginProvider: z.string(),
+  }),
+  roles: z.array(
+    z.object({
+      name: z.string(),
+      title: z.string(),
+      description: z.string().optional(),
+    }),
+  ),
+});
+
+/**
+ * @public
+ */
+export type OrganizationMember = z.output<typeof OrganizationMember>;
+
+/**
+ * Organization schema — validates and brands API responses
+ * from the `/organizations/:id` endpoint.
+ * @public
+ */
+export const Organization = z.object({
+  id: OrganizationId,
+  name: z.string(),
+  slug: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  dashboardStatus: z.enum(["enabled", "disabled"]),
+  aiFeaturesStatus: z.enum(["enabled", "disabled"]),
+  defaultRoleName: z.string().nullable(),
+});
+
+/**
+ * Represents an organization with optional members and
+ * features arrays depending on the generic parameters.
+ * - `Organization` — base fields only (default)
+ * - `Organization<true>` — includes `members`
+ * - `Organization<true, true>` — includes both
+ * @public
+ */
+export type Organization<
+  IncludeMembers extends boolean = true,
+  IncludeFeatures extends boolean = true,
+> = z.output<typeof Organization> &
+  (IncludeMembers extends true ? { members: OrganizationMember[] } : unknown) &
+  (IncludeFeatures extends true ? { features: string[] } : unknown);
+
+/**
+ * Validates and parses a raw API response into a branded
+ * Organization. The options control which schema is used —
+ * matching what the API returns based on query params.
+ * @public
+ */
+export function parseOrganization<
+  IncludeMembers extends boolean = true,
+  IncludeFeatures extends boolean = true,
+>(
+  data: unknown,
+  options?: {
+    includeMembers?: IncludeMembers;
+    includeFeatures?: IncludeFeatures;
+  },
+): Organization<IncludeMembers, IncludeFeatures> {
+  const includeMembers = options?.includeMembers ?? true;
+  const includeFeatures = options?.includeFeatures ?? true;
+
+  const extensions = {
+    ...(includeMembers && {
+      members: z.array(OrganizationMember),
+    }),
+    ...(includeFeatures && {
+      features: z.array(z.string()),
+    }),
+  };
+
+  const schema =
+    Object.keys(extensions).length > 0
+      ? Organization.extend(extensions)
+      : Organization;
+
+  return schema.parse(data) as Organization<IncludeMembers, IncludeFeatures>;
+}

package/src/core/projects.ts

@@ -0,0 +1,114 @@
+import { z } from "zod";
+
+import { OrganizationId } from "./organizations";
+
+/**
+ * Project ID schema, branded for type safety.
+ * @public
+ */
+export const ProjectId = z.string().nonempty().brand("ProjectId");
+
+/**
+ * Project ID type, branded for type safety.
+ * @public
+ */
+export type ProjectId = z.output<typeof ProjectId>;
+
+/**
+ * Validates and brands a string as a ProjectId.
+ * @public
+ */
+export function brandProjectId(id: string): ProjectId {
+  return ProjectId.parse(id);
+}
+
+const ProjectMember = z.object({
+  id: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  isCurrentUser: z.boolean(),
+  isRobot: z.boolean(),
+  roles: z.array(
+    z.object({
+      name: z.string(),
+      title: z.string(),
+      description: z.string(),
+    }),
+  ),
+});
+
+/**
+ * @public
+ */
+export type ProjectMember = z.output<typeof ProjectMember>;
+
+/**
+ * Project schema — validates and brands API responses
+ * from the `/projects/:id` endpoint.
+ * @public
+ */
+export const Project = z.object({
+  id: ProjectId,
+  displayName: z.string(),
+  studioHost: z.string().nullable(),
+  organizationId: OrganizationId,
+  metadata: z.object({
+    color: z.string().optional(),
+    externalStudioHost: z.string().optional(),
+    initialTemplate: z.string().optional(),
+    cliInitializedAt: z.string().optional(),
+    integration: z.string().optional(),
+  }),
+  isBlocked: z.boolean(),
+  isDisabled: z.boolean(),
+  isDisabledByUser: z.boolean(),
+  activityFeedEnabled: z.boolean(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+/**
+ * Represents a Sanity project with optional members and
+ * features arrays depending on the generic parameters.
+ * By default, neither members nor features are included.
+ * - `Project` — base fields only (default)
+ * - `Project<true>` — includes `members`
+ * - `Project<true, true>` — includes both
+ * @public
+ */
+export type Project<
+  IncludeMembers extends boolean = true,
+  IncludeFeatures extends boolean = true,
+> = z.output<typeof Project> &
+  (IncludeMembers extends true ? { members: ProjectMember[] } : unknown) &
+  (IncludeFeatures extends true ? { features: string[] } : unknown);
+
+/**
+ * Validates and parses a raw API response into a branded
+ * Project. The options control which schema is used —
+ * matching what the API returns based on query params.
+ * @public
+ */
+export function parseProject<
+  IncludeMembers extends boolean = true,
+  IncludeFeatures extends boolean = true,
+>(
+  data: unknown,
+  options?: {
+    includeMembers?: IncludeMembers;
+    includeFeatures?: IncludeFeatures;
+  },
+): Project<IncludeMembers, IncludeFeatures> {
+  const includeMembers = options?.includeMembers ?? true;
+  const includeFeatures = options?.includeFeatures ?? true;
+
+  const extensions = {
+    ...(includeMembers && { members: z.array(ProjectMember) }),
+    ...(includeFeatures && { features: z.array(z.string()) }),
+  };
+
+  const schema =
+    Object.keys(extensions).length > 0 ? Project.extend(extensions) : Project;
+
+  return schema.parse(data) as Project<IncludeMembers, IncludeFeatures>;
+}

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,148 @@
+// 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(),
+  group: z.string().optional(),
+  priority: z.number().optional(),
+});
+
+/**
+ * @public
+ */
+export type CoreAppUserApplicationManifest = z.output<
+  typeof CoreAppUserApplicationManifest
+>;
+
+const CoreAppUserApplicationBase = UserApplicationBase.extend({
+  title: z.string(),
+  organizationId: OrganizationId,
+  type: z.literal("coreApp"),
+});
+
+// Core apps surface their manifest exclusively via `activeDeployment.manifest`
+// — they have no top-level `manifest` field and no `manifestData`.
+const CoreAppActiveDeployment = ActiveDeployment.extend({
+  manifest: CoreAppUserApplicationManifest.nullable(),
+}).nullable();
+
+const InternalCoreAppUserApplication = CoreAppUserApplicationBase.extend({
+  urlType: z.literal("internal"),
+  activeDeployment: CoreAppActiveDeployment,
+});
+
+const ExternalCoreAppUserApplication = CoreAppUserApplicationBase.extend({
+  urlType: z.literal("external"),
+  activeDeployment: CoreAppActiveDeployment,
+});
+
+/**
+ * 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;
+  }
+
+  // Typed `string | null` so the UI-aware remote subclass can override it to
+  // `null` for a non-navigable app (US5, spec 002-workbench-extension-api); the core route itself is always set.
+  get href(): string | null {
+    return this.isLocal
+      ? `/local/${this.id}`
+      : `/application/${this.application.id}`;
+  }
+
+  get title() {
+    return this.manifest?.title ?? this.application.title;
+  }
+
+  /**
+   * Resolves the core app's manifest from `activeDeployment.manifest`. This
+   * is the canonical (and only) slot for core app manifests — both for
+   * Sanity-deployed apps and for local CLI dev-server apps, which synthesise
+   * a deployment to surface the live manifest.
+   */
+  get manifest(): CoreAppUserApplicationManifest | null {
+    return this.activeDeployment?.manifest ?? null;
+  }
+
+  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,128 @@
+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>;
+
+/**
+ * @public
+ */
+export const ServerManifest = z.object({
+  buildId: z.string().optional(),
+  bundleVersion: z.string().optional(),
+  version: z.string().optional(),
+  group: z.string().optional(),
+  priority: z.number().optional(),
+  workspaces: z
+    .array(
+      Workspace.extend({
+        dataset: z.string(),
+        schemaDescriptorId: z.string(),
+      }),
+    )
+    .optional(),
+});
+
+/**
+ * @public
+ */
+export type ServerManifest = z.output<typeof ServerManifest>;
+
+/**
+ * @public
+ */
+export const ClientManifest = z.object({
+  version: z.number(),
+  createdAt: z.string(),
+  studioVersion: z.string().optional(),
+  group: z.string().optional(),
+  priority: z.number().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"),
+  /**
+   * @deprecated Use `manifestData` instead.
+   */
+  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(),
+  }).nullable(),
+});
+
+const ExternalStudioUserApplication = StudioUserApplicationBase.extend({
+  urlType: z.literal("external"),
+  activeDeployment: ActiveDeployment.extend({
+    manifest: ServerManifest.nullable(),
+  }).nullable(),
+});
+
+/**
+ * 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);
+}