@sanity/workbench 0.0.1-alpha.0 → 0.1.0-alpha.10

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