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

package/src/core/user-applications/core-app.test.ts

@@ -1,8 +1,14 @@
+// eslint-disable-next-line no-restricted-imports
 import type { ApplicationResource as ProtocolApplicationResource } from "@sanity/message-protocol";
 import { afterEach, describe, expect, expectTypeOf, it, vi } from "vitest";
 
 import { APPLICATION_DATA } from "../__tests__/__fixtures__";
-import { CoreAppApplication } from "./core-app";
+import {
+  CoreAppApplication,
+  parseCoreApplication,
+  type CoreAppUserApplication,
+} from "./core-app";
+import type { UserApplicationId } from "./user-application";
 
 const setup = () => new CoreAppApplication(APPLICATION_DATA);
 
@@ -73,7 +79,6 @@ describe("CoreAppApplication", () => {
         "dashboardStatus": "default",
         "id": "v27rvqtlp3lmdvcln6ey3lro",
         "organizationId": "oSyH1iET5",
-        "projectId": null,
         "title": "sdk-movie-list",
         "type": "application",
         "updatedAt": "2025-03-27T19:00:32.792Z",
@@ -106,35 +111,35 @@ describe("CoreAppApplication", () => {
 
   describe("manifest functionality", () => {
     it("should use manifest from application when present", () => {
-      const applicationWithManifest = {
-        ...APPLICATION_DATA,
-        activeDeployment: {
-          ...APPLICATION_DATA.activeDeployment,
-          manifest: {
-            version: "1.0.0",
-            icon: "<svg>test-icon</svg>",
-            title: "Manifest Title",
+      const application = new CoreAppApplication(
+        parseCoreApplication({
+          ...APPLICATION_DATA,
+          activeDeployment: {
+            ...APPLICATION_DATA.activeDeployment!,
+            manifest: {
+              version: "1.0.0",
+              icon: "<svg>test-icon</svg>",
+              title: "Manifest Title",
+            },
           },
-        },
-      };
-      const application = new CoreAppApplication(applicationWithManifest);
+        }),
+      );
       expect(application.title).toBe("Manifest Title");
     });
 
     it("should use manifest from activeDeployment when application manifest is not present", () => {
-      const applicationWithDeploymentManifest = {
-        ...APPLICATION_DATA,
-        activeDeployment: {
-          ...APPLICATION_DATA.activeDeployment,
-          manifest: {
-            version: "1.0.0",
-            icon: "<svg>deployment-icon</svg>",
-            title: "Deployment Title",
-          },
-        },
-      };
       const application = new CoreAppApplication(
-        applicationWithDeploymentManifest,
+        parseCoreApplication({
+          ...APPLICATION_DATA,
+          activeDeployment: {
+            ...APPLICATION_DATA.activeDeployment!,
+            manifest: {
+              version: "1.0.0",
+              icon: "<svg>deployment-icon</svg>",
+              title: "Deployment Title",
+            },
+          },
+        }),
       );
       expect(application.title).toBe("Deployment Title");
     });
@@ -149,3 +154,83 @@ describe("CoreAppApplication", () => {
     });
   });
 });
+
+const VALID_INTERNAL_CORE_APP = {
+  id: "app-001",
+  appHost: "my-app-host",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-01-01T00:00:00Z",
+  dashboardStatus: "default",
+  title: "My App",
+  organizationId: "org-001",
+  type: "coreApp",
+  urlType: "internal",
+  activeDeployment: {
+    id: "deploy-001",
+    version: "1.0.0",
+    isActiveDeployment: true,
+    userApplicationId: "app-001",
+    isAutoUpdating: false,
+    manifest: null,
+    size: 500,
+    deployedAt: "2025-01-01T00:00:00Z",
+    deployedBy: "user-001",
+    createdAt: "2025-01-01T00:00:00Z",
+    updatedAt: "2025-01-01T00:00:00Z",
+  },
+} as const;
+
+const VALID_EXTERNAL_CORE_APP = {
+  id: "app-002",
+  appHost: "https://my-app.example.com",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-01-01T00:00:00Z",
+  dashboardStatus: "default",
+  title: "My External App",
+  organizationId: "org-001",
+  type: "coreApp",
+  urlType: "external",
+  activeDeployment: null,
+} as const;
+
+describe("parseCoreApplication", () => {
+  it("parses a valid internal core application", () => {
+    const app = parseCoreApplication(VALID_INTERNAL_CORE_APP);
+    expect(app.urlType).toBe("internal");
+    expect(app.title).toBe("My App");
+    expectTypeOf(app).toEqualTypeOf<CoreAppUserApplication>();
+    expectTypeOf(app.id).toEqualTypeOf<UserApplicationId>();
+  });
+
+  it("parses a valid external core application", () => {
+    const app = parseCoreApplication(VALID_EXTERNAL_CORE_APP);
+    expect(app.urlType).toBe("external");
+    expect(app.activeDeployment).toBeNull();
+  });
+
+  it("rejects missing required fields", () => {
+    expect(() => parseCoreApplication({ id: "app-001" })).toThrow();
+  });
+
+  it("rejects an empty id", () => {
+    expect(() =>
+      parseCoreApplication({ ...VALID_INTERNAL_CORE_APP, id: "" }),
+    ).toThrow();
+  });
+
+  it("parses core app with deployment manifest", () => {
+    const app = parseCoreApplication({
+      ...VALID_INTERNAL_CORE_APP,
+      activeDeployment: {
+        ...VALID_INTERNAL_CORE_APP.activeDeployment,
+        manifest: {
+          version: "1.0.0",
+          title: "Manifest Title",
+          icon: "<svg></svg>",
+        },
+      },
+    });
+
+    expect(app.activeDeployment?.manifest?.title).toBe("Manifest Title");
+  });
+});

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

@@ -1,21 +1,75 @@
-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 { z } from "zod";
 
-import { UserApplication } from "./user-application";
+import { OrganizationId } from "../organizations";
+import {
+  UserApplication,
+  UserApplicationBase,
+  ActiveDeployment,
+} from "./user-application";
+
+const CoreAppUserApplicationManifest = z.object({
+  version: z.string(),
+  icon: z.string().optional(),
+  title: z.string().optional(),
+});
+
+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(),
+  }),
+});
+
+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);
+}
 
 /**
  * @internal
  */
 export class CoreAppApplication extends UserApplication<
-  CoreApplication,
+  CoreAppUserApplication,
   "coreApp",
   ProtocolApplicationResource
 > {
-  readonly activeDeployment: CoreApplication["activeDeployment"];
+  readonly activeDeployment: CoreAppUserApplication["activeDeployment"];
 
-  constructor(application: CoreApplication) {
+  constructor(application: CoreAppUserApplication) {
     super(application, "coreApp");
 
     this.activeDeployment = application.activeDeployment;
@@ -37,7 +91,9 @@ export class CoreAppApplication extends UserApplication<
     return this.application.updatedAt;
   }
 
-  get<TKey extends keyof CoreApplication>(attr: TKey): CoreApplication[TKey] {
+  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}`,
@@ -52,6 +108,6 @@ export class CoreAppApplication extends UserApplication<
       ...this.application,
       type: "application",
       url: this.url.toString(),
-    } satisfies ProtocolApplicationResource;
+    } 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.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+
+import type { UserApplicationId } from "../user-application";
+import {
+  parseStudioUserApplication,
+  type StudioUserApplication,
+} from "./schemas";
+
+const VALID_INTERNAL_STUDIO = {
+  id: "studio-001",
+  appHost: "my-studio",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-01-01T00:00:00Z",
+  dashboardStatus: "default",
+  title: null,
+  projectId: "proj-001",
+  type: "studio",
+  urlType: "internal",
+  manifest: null,
+  manifestData: null,
+  autoUpdatingVersion: "latest",
+  activeDeployment: {
+    id: "deploy-001",
+    version: "4.0.0",
+    isActiveDeployment: true,
+    userApplicationId: "studio-001",
+    isAutoUpdating: true,
+    manifest: null,
+    size: 1000,
+    deployedAt: "2025-01-01T00:00:00Z",
+    deployedBy: "user-001",
+    createdAt: "2025-01-01T00:00:00Z",
+    updatedAt: "2025-01-01T00:00:00Z",
+  },
+  config: {},
+} as const;
+
+const VALID_EXTERNAL_STUDIO = {
+  id: "studio-002",
+  appHost: "https://my-studio.example.com",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-01-01T00:00:00Z",
+  dashboardStatus: "default",
+  title: "My External Studio",
+  projectId: "proj-001",
+  type: "studio",
+  urlType: "external",
+  manifest: null,
+  manifestData: null,
+  autoUpdatingVersion: null,
+  activeDeployment: null,
+  config: {},
+} as const;
+
+describe("parseStudioUserApplication", () => {
+  it("parses a valid internal studio application", () => {
+    const studio = parseStudioUserApplication(VALID_INTERNAL_STUDIO);
+    expect(studio.urlType).toBe("internal");
+    expect(studio.activeDeployment?.version).toBe("4.0.0");
+    expectTypeOf(studio).toEqualTypeOf<StudioUserApplication>();
+    expectTypeOf(studio.id).toEqualTypeOf<UserApplicationId>();
+  });
+
+  it("parses a valid external studio application", () => {
+    const studio = parseStudioUserApplication(VALID_EXTERNAL_STUDIO);
+    expect(studio.urlType).toBe("external");
+    expect(studio.activeDeployment).toBeNull();
+    expect(studio.title).toBe("My External Studio");
+  });
+
+  it("rejects missing required fields", () => {
+    expect(() => parseStudioUserApplication({ id: "studio-001" })).toThrow();
+  });
+
+  it("rejects an empty id", () => {
+    expect(() =>
+      parseStudioUserApplication({ ...VALID_INTERNAL_STUDIO, id: "" }),
+    ).toThrow();
+  });
+
+  it("rejects invalid urlType", () => {
+    expect(() =>
+      parseStudioUserApplication({
+        ...VALID_INTERNAL_STUDIO,
+        urlType: "unknown",
+      }),
+    ).toThrow();
+  });
+
+  it("parses studio with manifestData", () => {
+    const studio = parseStudioUserApplication({
+      ...VALID_INTERNAL_STUDIO,
+      manifestData: {
+        value: {
+          version: 2,
+          createdAt: "2025-01-01T00:00:00Z",
+          workspaces: [
+            {
+              name: "default",
+              title: "Default",
+              basePath: "/",
+              projectId: "proj-001",
+              dataset: "production",
+              schema: "schema.json",
+            },
+          ],
+        },
+      },
+    });
+
+    expect(studio.manifestData?.value.workspaces).toHaveLength(1);
+  });
+});

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