@supernova-studio/client 1.96.6 → 1.96.7

package/src/api/payloads/design-systems/update-design-system.ts

@@ -0,0 +1,42 @@
+import { DesignSystem, DesignSystemAccessMode, DesignSystemSwitcher, ObjectMeta } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTODesignSystemUpdateInput = DesignSystem.partial()
+  .omit({
+    id: true,
+    workspaceId: true,
+    createdAt: true,
+    updatedAt: true,
+    docSlug: true,
+    docViewUrl: true,
+    accessMode: true,
+    iconFileId: true,
+    iconFilePath: true,
+  })
+  .extend({
+    meta: ObjectMeta.partial().optional(),
+    iconFileId: z.string().nullish(),
+
+    /**
+     * @deprecated Use the `designSystems.updateSwitcher` endpoint instead
+     */
+    designSystemSwitcher: DesignSystemSwitcher.optional(),
+  });
+
+export const DTODesignSystemUpdateAccessModeInput = z.object({
+  accessMode: DesignSystemAccessMode,
+  retain: z
+    .object({
+      userIds: z.string().array(),
+      inviteIds: z.string().array(),
+    })
+    .optional(),
+});
+
+export const DTODesignSystemUpdateSwitcherInput = z.object({
+  designSystemSwitcher: DesignSystemSwitcher,
+});
+
+export type DTODesignSystemUpdateInput = z.infer<typeof DTODesignSystemUpdateInput>;
+export type DTODesignSystemUpdateAccessModeInput = z.infer<typeof DTODesignSystemUpdateAccessModeInput>;
+export type DTODesignSystemUpdateSwitcherInput = z.infer<typeof DTODesignSystemUpdateSwitcherInput>;

package/src/api/payloads/design-systems/version.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+
+export const ObjectMeta = z.object({
+  name: z.string().max(150).optional(),
+  description: z.string().max(2000).optional(),
+});
+
+export function validateDesignSystemVersion(version: string) {
+  const urlCompliantRegex = /^[a-zA-Z0-9+.-]+$/;
+  return urlCompliantRegex.test(version);
+}
+
+export const DTOCreateVersionInput = z.object({
+  meta: ObjectMeta,
+  version: z.string().refine(validateDesignSystemVersion, {
+    message: "Invalid semantic versioning format",
+  }),
+  changeLog: z.string().optional(),
+});
+
+export type DTOCreateVersionInput = z.infer<typeof DTOCreateVersionInput>;
+
+export const DTOUpdateVersionInput = z.object({
+  meta: ObjectMeta,
+  version: z.string(), // required for PUT, but not editable
+  changeLog: z.string(),
+});
+
+export type DTOUpdateVersionInput = z.infer<typeof DTOUpdateVersionInput>;

package/src/api/payloads/documentation/analytics.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+
+//
+// TO DELETE!
+//
+
+/**
+ * @deprecated
+ */
+export const DTODocumentationAnalyticsTimeFrameComparison = z.object({
+  referencePeriod: z.object({
+    start: z.coerce.date(),
+    end: z.coerce.date().optional(),
+  }),
+  baselinePeriod: z.object({
+    start: z.coerce.date(),
+    end: z.coerce.date().optional(),
+  }),
+});
+
+/**
+ * @deprecated
+ */
+export const DTODocumentationAnalyticsDiffPayload = z.object({
+  timeFrames: z.array(DTODocumentationAnalyticsTimeFrameComparison),
+});
+
+/**
+ * @deprecated
+ */
+export type DTODocumentationAnalyticsTimeFrameComparison = z.infer<typeof DTODocumentationAnalyticsTimeFrameComparison>;
+
+/**
+ * @deprecated
+ */
+export type DTODocumentationAnalyticsDiffPayload = z.infer<typeof DTODocumentationAnalyticsDiffPayload>;

package/src/api/payloads/documentation/block-definitions.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { zodQueryBoolean } from "../../../utils/query";
+import { DTOPageBlockDefinition } from "../../dto/documentation/block-definition";
+
+//
+// Read
+//
+
+export const DTOGetBlockDefinitionsQuery = z.object({
+  files: zodQueryBoolean(),
+});
+
+export const DTOGetBlockDefinitionsOutput = z.object({
+  definitions: z.array(DTOPageBlockDefinition),
+});
+
+export type DTOGetBlockDefinitionsOutput = z.infer<typeof DTOGetBlockDefinitionsOutput>;
+export type DTOGetBlockDefinitionsQuery = z.infer<typeof DTOGetBlockDefinitionsQuery>;

package/src/api/payloads/documentation/design-data-doc-diff.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+export const DTODocumentationPublishTypeQueryParams = z.object({
+  environment: z.enum(["Live", "Preview"]),
+});
+
+export type DTODocumentationPublishTypeQueryParams = z.infer<typeof DTODocumentationPublishTypeQueryParams>;

package/src/api/payloads/documentation/index.ts

@@ -0,0 +1,3 @@
+export * from "./analytics";
+export * from "./block-definitions";
+export * from "./design-data-doc-diff";

package/src/api/payloads/export/index.ts

@@ -0,0 +1 @@
+export * from "./pipeline";

package/src/api/payloads/export/pipeline.ts

@@ -0,0 +1,111 @@
+import {
+  ExporterDestinationAzure,
+  ExporterDestinationBitbucket,
+  ExporterDestinationDocs,
+  ExporterDestinationGithub,
+  ExporterDestinationGitlab,
+  ExporterDestinationS3,
+  GitObjectsQuery,
+  PipelineDestinationType,
+  PipelineEventType,
+} from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOExporterPropertyValueMap } from "../../dto/export/exporter-property";
+
+export const GitDestinationOptions = z.object({
+  branch: z.string().min(1).nullish(),
+  commitMessage: z.string().min(1).nullish(),
+  commitAuthorName: z.string().min(1).nullish(),
+  commitAuthorEmail: z.string().email().nullish(),
+  pullRequestTitle: z.string().min(1).nullish(),
+  pullRequestDescription: z.string().min(1).nullish(),
+  relativePath: z.string().nullish(),
+  purgeDirectory: z.boolean().nullish(),
+});
+
+export const DTOPipelineCreateBody = z.object({
+  name: z.string(),
+  exporterId: z.string(),
+  designSystemId: z.string(),
+  isEnabled: z.boolean(),
+  eventType: PipelineEventType,
+  brandPersistentId: z.string().optional(),
+  themePersistentId: z.string().optional(),
+  themePersistentIds: z.string().array().optional(),
+
+  exporterPropertyValues: DTOExporterPropertyValueMap.optional(),
+
+  destination: PipelineDestinationType.optional(),
+  gitQuery: GitObjectsQuery,
+  destinations: z.object({
+    s3: ExporterDestinationS3.nullish(),
+    azure: ExporterDestinationAzure.nullish(),
+    bitbucket: ExporterDestinationBitbucket.nullish(),
+    github: ExporterDestinationGithub.nullish(),
+    gitlab: ExporterDestinationGitlab.nullish(),
+    documentation: ExporterDestinationDocs.nullish(),
+    webhookUrl: z.string().nullish(),
+  }),
+});
+
+export const DTODesignSystemPipelineCreateBody = z.object({
+  name: z.string(),
+  exporterId: z.string(),
+  isEnabled: z.boolean(),
+  eventType: PipelineEventType,
+  brandPersistentId: z.string().optional(),
+  themePersistentId: z.string().optional(),
+  themePersistentIds: z.string().array().optional(),
+
+  exporterPropertyValues: DTOExporterPropertyValueMap.optional(),
+
+  destination: PipelineDestinationType.optional(),
+  gitQuery: GitObjectsQuery,
+  destinations: z.object({
+    s3: ExporterDestinationS3.nullish(),
+    azure: ExporterDestinationAzure.nullish(),
+    bitbucket: ExporterDestinationBitbucket.nullish(),
+    github: ExporterDestinationGithub.nullish(),
+    gitlab: ExporterDestinationGitlab.nullish(),
+    documentation: ExporterDestinationDocs.nullish(),
+    webhookUrl: z.string().nullish(),
+  }),
+});
+export const DTOPipelineUpdateBody = z.object({
+  exporterId: z.string().optional(),
+  name: z.string().optional(),
+  isEnabled: z.boolean().optional(),
+  eventType: PipelineEventType.optional(),
+
+  brandPersistentId: z.string().optional(),
+  themePersistentId: z.string().optional(),
+  themePersistentIds: z.string().array().optional(),
+
+  exporterPropertyValues: DTOExporterPropertyValueMap.optional(),
+
+  destination: PipelineDestinationType.optional(),
+  gitQuery: GitObjectsQuery.optional(),
+
+  destinations: z
+    .object({
+      s3: ExporterDestinationS3.nullish(),
+      azure: ExporterDestinationAzure.nullish(),
+      bitbucket: ExporterDestinationBitbucket.nullish(),
+      github: ExporterDestinationGithub.nullish(),
+      gitlab: ExporterDestinationGitlab.nullish(),
+      documentation: ExporterDestinationDocs.nullish(),
+      webhookUrl: z.string().nullish(),
+    })
+    .optional(),
+  gitDestinationOptions: GitDestinationOptions.partial().optional(),
+});
+
+export const DTOPipelineTriggerBody = z.object({
+  designSystemVersionId: z.string(),
+});
+
+export type GitDestinationOptions = z.infer<typeof GitDestinationOptions>;
+export type DTOPipelineCreateBody = z.infer<typeof DTOPipelineCreateBody>;
+export type DTOPipelineUpdateBody = z.infer<typeof DTOPipelineUpdateBody>;
+export type DTOPipelineTriggerBody = z.infer<typeof DTOPipelineTriggerBody>;
+export type DTODesignSystemPipelineCreateBody = z.infer<typeof DTODesignSystemPipelineCreateBody>;

package/src/api/payloads/index.ts

@@ -0,0 +1,6 @@
+export * from "./design-systems";
+export * from "./documentation";
+export * from "./export";
+export * from "./liveblocks";
+export * from "./users";
+export * from "./workspaces";

package/src/api/payloads/liveblocks/auth.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+export const DTOLiveblocksAuthRequest = z.object({
+  room: z.string().optional(),
+});
+
+export type DTOLiveblocksAuthRequest = z.infer<typeof DTOLiveblocksAuthRequest>;

package/src/api/payloads/liveblocks/index.ts

@@ -0,0 +1 @@
+export * from "./auth";

package/src/api/payloads/users/index.ts

@@ -0,0 +1 @@
+export * from "./notifications";

package/src/api/payloads/users/notifications/index.ts

@@ -0,0 +1 @@
+export * from "./notification-settings";

package/src/api/payloads/users/notifications/notification-settings.ts

@@ -0,0 +1,17 @@
+import { UserNotificationSettings } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOUpdateUserNotificationSettingsPayload = z.object({
+    notificationSettings: UserNotificationSettings,
+});
+
+export type DTOUpdateUserNotificationSettingsPayload = z.infer<typeof DTOUpdateUserNotificationSettingsPayload>;
+
+
+export const DTOUserNotificationSettingsResponse = z.object({
+    userId: z.string(),
+    workspaceId: z.string(),
+    notificationSettings: UserNotificationSettings,
+});
+
+export type DTOUserNotificationSettingsResponse = z.infer<typeof DTOUserNotificationSettingsResponse>;

package/src/api/payloads/workspaces/index.ts

@@ -0,0 +1,2 @@
+export * from "./workspace-configuration";
+export * from "./workspace-integrations";

package/src/api/payloads/workspaces/workspace-configuration.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import {
+  SsoProvider,
+  WorkspaceDefaultProjectAccessMode,
+  WorkspaceDefaultProjectRole,
+  WorkspaceIpSettings,
+  WorkspaceProfile,
+} from "@supernova-studio/model";
+
+const prohibitedSsoKeys = ["providerId", "metadataXml", "emailDomains"];
+
+export function validateSsoPayload(ssoPayload: Partial<SsoProvider> | undefined) {
+  const keys = [];
+  let valid = true;
+  if (!ssoPayload) {
+    valid = true;
+    return {
+      valid,
+      keys: [],
+    };
+  }
+  for (const key of Object.keys(ssoPayload)) {
+    if (prohibitedSsoKeys.includes(key)) {
+      keys.push(key);
+      valid = false;
+    }
+  }
+  return {
+    valid,
+    keys,
+  };
+}
+
+export const NpmRegistryInput = z.object({
+  enabledScopes: z.array(z.string()),
+  customRegistryUrl: z.string().optional(),
+  bypassProxy: z.boolean().optional(),
+  npmProxyRegistryConfigId: z.string().optional(),
+  npmProxyVersion: z.number().optional(),
+  registryType: z.string(),
+  authType: z.string(),
+  authHeaderName: z.string(),
+  authHeaderValue: z.string(),
+  accessToken: z.string(),
+  username: z.string(),
+  password: z.string(),
+});
+
+export const WorkspaceConfigurationPayload = z.object({
+  ipWhitelist: WorkspaceIpSettings.partial().optional(),
+  sso: SsoProvider.partial().optional(),
+  npmRegistrySettings: NpmRegistryInput.partial().optional(),
+  profile: WorkspaceProfile.partial().optional(),
+  aiFeaturesEnabled: z.boolean().optional(),
+  projectsEnabled: z.boolean().optional(),
+  defaultProjectAccessMode: WorkspaceDefaultProjectAccessMode.optional(),
+  defaultProjectRole: WorkspaceDefaultProjectRole.optional(),
+  aiAskFeaturesEnabled: z.boolean().optional(),
+  aiCustomInstruction: z.string().optional(),
+});
+
+export type WorkspaceConfigurationPayload = z.infer<typeof WorkspaceConfigurationPayload>;

package/src/api/payloads/workspaces/workspace-integrations.ts

@@ -0,0 +1,35 @@
+import { IntegrationToken, IntegrationType } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const IntegrationOauthPlatform = z.enum(["Desktop", "Browser"]);
+
+export type IntegrationOauthPlatform = z.infer<typeof IntegrationOauthPlatform>;
+
+export const IntegrationOauthCallbackState = z.enum(["Success", "Error"]);
+
+export type IntegrationOauthCallbackState = z.infer<typeof IntegrationOauthCallbackState>;
+
+export const DTOWorkspaceIntegrationOauthInput = z.object({
+  type: IntegrationType,
+  platform: IntegrationOauthPlatform.optional().default("Browser"),
+  authId: z.string().optional(), // Allow FE client to distinguish between multiple parallel OAuth flows, useful for desktop where multiple flows can be initiated in parallel
+});
+
+export type DTOWorkspaceIntegrationOauthInput = z.infer<typeof DTOWorkspaceIntegrationOauthInput>;
+
+export const DTOWorkspaceIntegrationPATInput = z.object({
+  type: IntegrationType,
+  token: IntegrationToken,
+});
+
+export type DTOWorkspaceIntegrationPATInput = z.infer<typeof DTOWorkspaceIntegrationPATInput>;
+
+export const DTOWorkspaceIntegrationGetGitObjectsInput = z.object({
+  organization: z.string().optional(), // Azure Organization | Bitbucket Workspace slug | Gitlab Group and Sub-Groups | Github Account (User or Organization)
+  project: z.string().optional(), // Only for Bitbucket and Azure
+  repository: z.string().optional(), // For all providers. Pay attention for Gitlab, they call repositories "projects".
+  branch: z.string().optional(), // For all providers, useful for PR creations.
+  user: z.string().optional(), // Only for Gitlab User Repositories
+});
+
+export type DTOWorkspaceIntegrationGetGitObjectsInput = z.infer<typeof DTOWorkspaceIntegrationGetGitObjectsInput>;

package/src/api/transport/index.ts

@@ -0,0 +1,2 @@
+export * from "./request-executor-error";
+export * from "./request-executor";

package/src/api/transport/request-executor-error.ts

@@ -0,0 +1,60 @@
+import { SupernovaExceptionType } from "@supernova-studio/model";
+
+export type RequestExecutorErrorType = "ServerError" | "ResponseParsingError";
+export type RequestEexecutorServerErrorCode = SupernovaExceptionType | undefined;
+
+export class RequestExecutorError extends Error {
+  readonly type: RequestExecutorErrorType;
+  readonly errorCode: RequestEexecutorServerErrorCode | undefined;
+  readonly serverErrorType: SupernovaExceptionType | undefined;
+
+  static tryParseJSON(body: string) {
+    try {
+      return JSON.parse(body);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  static serverError(endpoint: string, status: number, bodyText: string) {
+    const parsedBody = this.tryParseJSON(bodyText);
+    return new RequestExecutorError(
+      "ServerError",
+      `Endpoint ${endpoint} returned ${status}\n${bodyText}`,
+      parsedBody?.errorCode ?? null,
+      parsedBody?.type ?? null,
+      parsedBody ?? null
+    );
+  }
+
+  static responseParsingError(endpoint: string, cause: Error) {
+    return new RequestExecutorError(
+      "ResponseParsingError",
+      `Endpoint ${endpoint} returned incompatible JSON`,
+      undefined,
+      undefined,
+      cause
+    );
+  }
+
+  getDisplayMessage(): string {
+    if (this.type === "ServerError" && this.cause && typeof this.cause === "object" && "message" in this.cause) {
+      return (this.cause as { message: string }).message || this.message;
+    }
+
+    return this.message;
+  }
+
+  private constructor(
+    type: RequestExecutorErrorType,
+    message: string,
+    errorCode: RequestEexecutorServerErrorCode | undefined,
+    serverErrorType?: SupernovaExceptionType | undefined,
+    cause?: unknown
+  ) {
+    super(`${type}: ${message}`, { cause });
+    this.type = type;
+    this.errorCode = errorCode;
+    this.serverErrorType = serverErrorType;
+  }
+}

package/src/api/transport/request-executor.ts

@@ -0,0 +1,94 @@
+import { z, ZodSchema, ZodTypeDef } from "zod";
+import { RequestExecutorError } from "./request-executor-error";
+
+export type RequestExecutorConfig = {
+  baseUrl: string;
+  accessToken?: string;
+  apiSecret?: string;
+};
+
+export type RequestExecutorJSONRequest = Omit<RequestInit, "body"> & {
+  body?: object;
+  query?: URLSearchParams;
+};
+
+const ResponseWrapper = z.object({
+  result: z.record(z.any()),
+});
+
+export class RequestExecutor {
+  private readonly testServerConfig: RequestExecutorConfig;
+
+  constructor(testServerConfig: RequestExecutorConfig) {
+    this.testServerConfig = testServerConfig;
+  }
+
+  async json<O, I>(
+    path: `/${string}`,
+    schema: ZodSchema<O, ZodTypeDef, I>,
+    requestInit: RequestExecutorJSONRequest = {}
+  ) {
+    // Headers
+    const defaultHeaders: Record<string, string> = {
+      Accept: "application/json",
+    };
+
+    if (requestInit.body) defaultHeaders["Content-Type"] = "application/json";
+
+    if (this.testServerConfig.accessToken) {
+      defaultHeaders["Authorization"] = `Bearer ${this.testServerConfig.accessToken}`;
+    }
+
+    // API secret allows for more priviledged access from secure environments (e.g. other servers)
+    if (this.testServerConfig.apiSecret) {
+      defaultHeaders["x-sn-api-secret"] = this.testServerConfig.apiSecret;
+    }
+
+    // Body
+    let body: string | undefined;
+    if (requestInit.body && typeof requestInit.body === "object") body = JSON.stringify(requestInit.body);
+
+    const fullUrl = this.fullUrl(path, requestInit.query);
+    const response = await fetch(fullUrl, {
+      ...requestInit,
+      headers: {
+        ...requestInit.headers,
+        ...defaultHeaders,
+      },
+      body: body,
+    });
+
+    const endpoint = `${requestInit.method ?? "GET"} ${path}`;
+
+    if (!response.ok) {
+      const bodyString = await response.text();
+      throw RequestExecutorError.serverError(endpoint, response.status, bodyString);
+    }
+
+    const json = await response.json();
+    const wrapperParseResult = ResponseWrapper.safeParse(json);
+    if (!wrapperParseResult.success) {
+      console.error(`Response was:`);
+      console.error(json);
+      throw RequestExecutorError.responseParsingError(endpoint, wrapperParseResult.error);
+    }
+
+    const responseParseResult = schema.safeParse(wrapperParseResult.data.result);
+    if (!responseParseResult.success) {
+      console.error(`Response was:`);
+      console.error(wrapperParseResult.data.result);
+      throw RequestExecutorError.responseParsingError(endpoint, responseParseResult.error);
+    }
+
+    return responseParseResult.data;
+  }
+
+  private fullUrl(path: string, query: URLSearchParams | undefined): string {
+    let url = `${this.testServerConfig.baseUrl}/api/v2${path}`;
+
+    const queryString = query?.toString();
+    if (queryString) url += `?${queryString}`;
+
+    return url;
+  }
+}

package/src/events/design-system.ts

@@ -0,0 +1,21 @@
+import { DataSourceRemoteType } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOEventFigmaNodesRendered = z.object({
+  type: z.literal("DesignSystem.FigmaNodesRendered"),
+  designSystemId: z.string(),
+  versionId: z.string(),
+  figmaNodePersistentIds: z.string().array(),
+});
+
+export const DTOEventDataSourcesImported = z.object({
+  type: z.literal("DesignSystem.ImportJobFinished"),
+  designSystemId: z.string(),
+  versionId: z.string(),
+  importJobId: z.string(),
+  dataSourceType: DataSourceRemoteType,
+  dataSourceIds: z.string().array(),
+});
+
+export type DTOEventFigmaNodesRendered = z.infer<typeof DTOEventFigmaNodesRendered>;
+export type DTOEventDataSourcesImported = z.infer<typeof DTOEventDataSourcesImported>;

package/src/events/event.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+import { DTOEventDataSourcesImported, DTOEventFigmaNodesRendered } from "./design-system";
+
+export const DTOEvent = z.discriminatedUnion("type", [DTOEventDataSourcesImported, DTOEventFigmaNodesRendered]);
+
+export type DTOEvent = z.infer<typeof DTOEvent>;

package/src/events/index.ts

@@ -0,0 +1,2 @@
+export * from "./design-system";
+export * from "./event";

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./api";
+export * from "./events";
+export * from "./sync";
+export * from "./utils";
+export * from "./yjs";