@supernova-studio/client 1.96.5 → 1.96.7

package/src/api/dto/export/exporter-property.ts

@@ -0,0 +1,114 @@
+import { z } from "zod";
+
+//
+// Primitives
+//
+
+const PrimitiveValue = z.number().or(z.boolean()).or(z.string());
+const ArrayValue = z.array(z.string());
+const ObjectValue = z.record(z.string());
+
+export const DTOExporterPropertyValue = PrimitiveValue.or(ArrayValue).or(ObjectValue);
+export const DTOExporterPropertyType = z.enum(["Enum", "Boolean", "String", "Number", "Array", "Object", "Code"]);
+
+export type DTOExporterPropertyDefinitionValue = z.infer<typeof DTOExporterPropertyValue>;
+export type DTOExporterPropertyType = z.infer<typeof DTOExporterPropertyType>;
+
+//
+// Property
+//
+
+const PropertyDefinitionBase = z.object({
+  key: z.string(),
+  title: z.string(),
+  description: z.string(),
+  category: z.string().optional(),
+  dependsOn: z.record(z.boolean()).optional(),
+});
+
+export type DTOPropertyDefinitionBase = z.infer<typeof PropertyDefinitionBase>;
+export const DTOExporterPropertyDefinitionEnumOption = z.object({
+  label: z.string(),
+  description: z.string(),
+});
+
+export const DTOExporterPropertyDefinitionEnum = PropertyDefinitionBase.extend({
+  type: z.literal(DTOExporterPropertyType.Enum.Enum),
+  options: z.record(DTOExporterPropertyDefinitionEnumOption),
+  default: z.string(),
+});
+
+export const DTOExporterPropertyDefinitionBoolean = PropertyDefinitionBase.extend({
+  type: z.literal(DTOExporterPropertyType.Enum.Boolean),
+  default: z.boolean(),
+});
+
+export const DTOExporterPropertyDefinitionString = PropertyDefinitionBase.extend({
+  type: z.literal(DTOExporterPropertyType.Enum.String),
+  default: z.string(),
+  isMultiline: z.boolean().optional(),
+});
+
+export const DTOExporterPropertyDefinitionNumber = PropertyDefinitionBase.extend({
+  type: z.literal(DTOExporterPropertyType.Enum.Number),
+  default: z.number(),
+});
+
+export const DTOExporterPropertyDefinitionArray = PropertyDefinitionBase.extend({
+  type: z.literal(DTOExporterPropertyType.Enum.Array),
+  default: ArrayValue,
+});
+
+export const DTOExporterPropertyDefinitionObject = PropertyDefinitionBase.extend({
+  type: z.literal(DTOExporterPropertyType.Enum.Object),
+  default: ObjectValue,
+  allowedKeys: z
+    .object({
+      options: z.string().array(),
+      type: z.string(),
+    })
+    .optional(),
+  allowedValues: z
+    .object({
+      type: z.string(),
+    })
+    .optional(),
+});
+
+export const DTOExporterPropertyDefinitionCode = PropertyDefinitionBase.extend({
+  type: z.literal(DTOExporterPropertyType.Enum.Code),
+  language: z.string(),
+  default: z.string(),
+});
+
+export const DTOExporterPropertyDefinition = z.discriminatedUnion("type", [
+  DTOExporterPropertyDefinitionEnum,
+  DTOExporterPropertyDefinitionBoolean,
+  DTOExporterPropertyDefinitionString,
+  DTOExporterPropertyDefinitionNumber,
+  DTOExporterPropertyDefinitionArray,
+  DTOExporterPropertyDefinitionObject,
+  DTOExporterPropertyDefinitionCode,
+]);
+
+export const DTOExporterPropertyDefinitionsResponse = z.object({
+  properties: DTOExporterPropertyDefinition.array(),
+});
+
+export type DTOExporterPropertyDefinitionEnum = z.infer<typeof DTOExporterPropertyDefinitionEnum>;
+export type DTOExporterPropertyDefinitionBoolean = z.infer<typeof DTOExporterPropertyDefinitionBoolean>;
+export type DTOExporterPropertyDefinitionString = z.infer<typeof DTOExporterPropertyDefinitionString>;
+export type DTOExporterPropertyDefinitionNumber = z.infer<typeof DTOExporterPropertyDefinitionNumber>;
+export type DTOExporterPropertyDefinitionArray = z.infer<typeof DTOExporterPropertyDefinitionArray>;
+export type DTOExporterPropertyDefinitionObject = z.infer<typeof DTOExporterPropertyDefinitionObject>;
+export type DTOExporterPropertyDefinitionCode = z.infer<typeof DTOExporterPropertyDefinitionCode>;
+export type DTOExporterPropertyDefinition = z.infer<typeof DTOExporterPropertyDefinition>;
+export type DTOExporterPropertyDefinitionEnumOption = z.infer<typeof DTOExporterPropertyDefinitionEnumOption>;
+export type DTOExporterPropertyDefinitionsResponse = z.infer<typeof DTOExporterPropertyDefinitionsResponse>;
+
+//
+// Value
+//
+
+export const DTOExporterPropertyValueMap = z.record(DTOExporterPropertyValue);
+export type DTOExporterPropertyValueMap = z.infer<typeof DTOExporterPropertyValueMap>;

package/src/api/dto/export/exporter.ts

@@ -0,0 +1,115 @@
+import {
+  nullishToOptional,
+  PulsarContributionConfigurationProperty,
+  PulsarContributionVariant,
+  PulsarCustomBlock,
+} from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOExporterPropertyDefinition } from "./exporter-property";
+
+//
+// Read
+//
+
+export const DTOExporterType = z.enum(["documentation", "code"]);
+export const DTOExporterSource = z.enum(["git", "upload"]);
+export const DTOExporterMembershipRole = z.enum(["Owner", "OwnerArchived", "User"]);
+
+export const DTOExporterListQuery = z.object({
+  limit: z.coerce.number().optional(),
+  offset: z.coerce.number().optional(),
+  type: DTOExporterType.optional(),
+  search: z.string().optional(),
+});
+
+export const DTOExporter = z.object({
+  id: z.string(),
+  name: z.string(),
+  isPrivate: z.boolean(),
+  exporterType: DTOExporterType,
+  isDefaultDocumentationExporter: z.boolean(),
+
+  iconURL: z.string().optional(),
+  configurationProperties: PulsarContributionConfigurationProperty.array(),
+  properties: DTOExporterPropertyDefinition.array().optional(),
+  customBlocks: PulsarCustomBlock.array(),
+  blockVariants: z.record(z.string(), PulsarContributionVariant.array()),
+
+  homepage: z.string().optional(),
+  organization: z.string().optional(),
+  packageId: z.string().optional(),
+  tags: z.array(z.string()),
+  author: z.string().optional(),
+  version: z.string(),
+  description: z.string(),
+
+  usesLocale: z.boolean(),
+  usesBrands: z.boolean(),
+  usesThemes: z.boolean(),
+
+  readme: z.string().optional(),
+  routingVersion: z.string().optional(),
+
+  source: DTOExporterSource,
+
+  gitProvider: z.string().optional(),
+  gitUrl: nullishToOptional(z.string()),
+  gitBranch: nullishToOptional(z.string()),
+  gitDirectory: nullishToOptional(z.string()),
+
+  isDeprecated: z.boolean(),
+  deprecationNote: z.string().optional(),
+  replacementExporterId: z.string().optional(),
+});
+
+export const DTOExporterMembership = z.object({
+  workspaceId: z.string(),
+  exporterId: z.string(),
+  role: DTOExporterMembershipRole,
+});
+
+export const DTOExporterResponse = z.object({
+  exporter: DTOExporter,
+  membership: DTOExporterMembership,
+});
+
+export const DTOExporterListResponse = z.object({
+  exporters: DTOExporter.array(),
+  membership: DTOExporterMembership.array(),
+  total: z.number(),
+});
+
+export type DTOExporterListQuery = z.infer<typeof DTOExporterListQuery>;
+export type DTOExporterType = z.infer<typeof DTOExporterType>;
+export type DTOExporterSource = z.infer<typeof DTOExporterSource>;
+export type DTOExporterMembershipRole = z.infer<typeof DTOExporterMembershipRole>;
+export type DTOExporter = z.infer<typeof DTOExporter>;
+export type DTOExporterMembership = z.infer<typeof DTOExporterMembership>;
+export type DTOExporterResponse = z.infer<typeof DTOExporterResponse>;
+export type DTOExporterListResponse = z.infer<typeof DTOExporterListResponse>;
+
+//
+// Write
+//
+
+export const DTOExporterGitProviderEnum = z.enum(["github", "gitlab", "bitbucket", "azure"]);
+
+export const DTOExporterCreateInput = z.object({
+  url: z.string(),
+  provider: DTOExporterGitProviderEnum,
+});
+
+export const DTOExporterUpdateInput = z.object({
+  url: z.string().optional(),
+});
+
+export const DTOExporterDeprecationInput = z.object({
+  isDeprecated: z.boolean(),
+  deprecationNote: z.string().optional(),
+  replacementExporterId: z.string().optional(),
+});
+
+export type DTOExporterGitProviderEnum = z.infer<typeof DTOExporterGitProviderEnum>;
+export type DTOExporterCreateInput = z.infer<typeof DTOExporterCreateInput>;
+export type DTOExporterUpdateInput = z.infer<typeof DTOExporterUpdateInput>;
+export type DTOExporterDeprecationInput = z.infer<typeof DTOExporterDeprecationInput>;

package/src/api/dto/export/filter.ts

@@ -0,0 +1,20 @@
+import { ExportJobDestinationType, ExportJobStatus, PublishedDocEnvironment } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOExportJobsListFilter = z.object({
+  exporterId: z.string().optional(),
+  designSystemVersionId: z.string().optional(),
+  createdByUserId: z.string().optional(),
+  status: ExportJobStatus.optional(),
+  scheduleId: z.string().optional(),
+  designSystemId: z.string().optional(),
+  themeId: z.string().optional(),
+  brandId: z.string().optional(),
+  docsEnvironment: PublishedDocEnvironment.optional(),
+  destinations: z
+    .string()
+    .transform(s => s.split(",").map(p => ExportJobDestinationType.parse(p)))
+    .optional(),
+});
+
+export type DTOExportJobsListFilter = z.infer<typeof DTOExportJobsListFilter>;

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

@@ -0,0 +1,5 @@
+export * from "./exporter-property";
+export * from "./exporter";
+export * from "./filter";
+export * from "./job";
+export * from "./pipeline";

package/src/api/dto/export/job.ts

@@ -0,0 +1,114 @@
+import {
+  ExportJobDocsDestinationResult,
+  ExportJobResult,
+  ExportJobStatus,
+  ExporterDestinationAzure,
+  ExporterDestinationBitbucket,
+  ExporterDestinationDocs,
+  ExporterDestinationGithub,
+  ExporterDestinationGitlab,
+  ExporterDestinationS3,
+  ObjectMeta,
+} from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOExporterPropertyValueMap } from "./exporter-property";
+
+export const DTOExportJobCreatedBy = z.object({
+  userId: z.string(),
+  userName: z.string(),
+});
+
+export const DTOExportJobDesignSystemPreview = z.object({
+  id: z.string(),
+  meta: ObjectMeta,
+});
+
+export const DTOExportJobDesignSystemVersionPreview = z.object({
+  id: z.string(),
+  meta: ObjectMeta,
+  version: z.string(),
+  isReadonly: z.boolean(),
+});
+
+export const DTOExportJobDestinations = z.object({
+  s3: ExporterDestinationS3.optional(),
+  azure: ExporterDestinationAzure.optional(),
+  bitbucket: ExporterDestinationBitbucket.optional(),
+  github: ExporterDestinationGithub.optional(),
+  gitlab: ExporterDestinationGitlab.optional(),
+  documentation: ExporterDestinationDocs.optional(),
+  webhookUrl: z.string().optional(),
+});
+
+export const DTOExportJobResult = ExportJobResult.omit({
+  sndocs: true,
+}).extend({
+  documentation: ExportJobDocsDestinationResult.optional(),
+});
+
+export const DTOExportJob = z.object({
+  id: z.string(),
+
+  createdAt: z.coerce.date(),
+  finishedAt: z.coerce.date().optional(),
+
+  index: z.number().optional(),
+  status: ExportJobStatus,
+  estimatedExecutionTime: z.number().optional(),
+
+  createdBy: DTOExportJobCreatedBy.optional(),
+  designSystem: DTOExportJobDesignSystemPreview,
+  designSystemVersion: DTOExportJobDesignSystemVersionPreview,
+
+  destinations: DTOExportJobDestinations,
+
+  exporterId: z.string(),
+  scheduleId: z.string().optional(),
+
+  result: DTOExportJobResult.optional(),
+
+  brandPersistentId: z.string().optional(),
+  themePersistentId: z.string().optional(),
+  themePersistentIds: z.string().array().optional(),
+
+  exporterPropertyValues: DTOExporterPropertyValueMap.optional(),
+});
+
+export const DTOExportJobResponse = z.object({
+  job: DTOExportJob,
+});
+
+// Deprecated: Use only for test purposes and extend if only necessary. This defines the BE response for an export job.
+export const DTOExportJobResponseLegacy = z.object({
+  job: z.object({
+    id: z.string(),
+    status: ExportJobStatus,
+  }),
+});
+
+export type DTOExportJobResponseLegacy = z.infer<typeof DTOExportJobResponseLegacy>;
+export type DTOExportJobCreatedBy = z.infer<typeof DTOExportJobCreatedBy>;
+export type DTOExportJobDesignSystemPreview = z.infer<typeof DTOExportJobDesignSystemPreview>;
+export type DTOExportJobDesignSystemVersionPreview = z.infer<typeof DTOExportJobDesignSystemVersionPreview>;
+export type DTOExportJobDestinations = z.infer<typeof DTOExportJobDestinations>;
+export type DTOExportJobResult = z.infer<typeof DTOExportJobResult>;
+export type DTOExportJob = z.infer<typeof DTOExportJob>;
+export type DTOExportJobResponse = z.infer<typeof DTOExportJobResponse>;
+
+//
+// Write
+//
+
+export const DTOExportJobCreateInput = z.object({
+  designSystemId: z.string(),
+  designSystemVersionId: z.string(),
+  exporterId: z.string(),
+  brandId: z.string().optional(),
+  themeId: z.string().optional(),
+  themePersistentIds: z.string().array().optional(),
+  destinations: DTOExportJobDestinations,
+  exporterPropertyValues: DTOExporterPropertyValueMap.optional(),
+  previewMode: z.boolean().optional(),
+});
+
+export type DTOExportJobCreateInput = z.infer<typeof DTOExportJobCreateInput>;

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

@@ -0,0 +1,60 @@
+import { ExportDestinationsMap, PipelineEventType, PipelineExporterQuery } from "@supernova-studio/model";
+import { z } from "zod";
+import { DTOExporterPropertyValueMap } from "./exporter-property";
+import { DTOExportJob } from "./job";
+
+export const DTOPipelineExporterQuery = PipelineExporterQuery;
+
+export const DTODesignSystemPipelineListQuery = DTOPipelineExporterQuery.extend({
+  latestJobsLimit: z.coerce.number().optional(),
+});
+
+export const DTOPipelineListQuery = z.object({
+  designSystemId: z.string().optional(),
+  exporterId: z.string().optional(),
+  latestJobsLimit: z.coerce.number().optional(),
+});
+
+export const DTOPipeline = z.object({
+  id: z.string(),
+  name: z.string(),
+  eventType: PipelineEventType,
+  isEnabled: z.boolean(),
+  workspaceId: z.string(),
+  designSystemId: z.string(),
+  exporterId: z.string(),
+  brandPersistentId: z.string().optional(),
+
+  themePersistentId: z.string().optional(),
+  themePersistentIds: z.string().array().optional(),
+
+  exporterPropertyValues: DTOExporterPropertyValueMap.optional(),
+
+  ...ExportDestinationsMap.shape,
+
+  latestJobs: DTOExportJob.array(),
+
+  isExporterDeprecated: z.boolean(),
+});
+
+export const DTOPipelineListResponse = z.object({
+  pipelines: DTOPipeline.array(),
+});
+
+export const DTOPipelineResponse = z.object({
+  pipeline: DTOPipeline,
+});
+
+export const DTOWorkspaceStats = z.object({
+  pipelines: z.object({
+    totalCount: z.number(),
+  }),
+});
+
+export type DTODesignSystemPipelineListQuery = z.infer<typeof DTODesignSystemPipelineListQuery>;
+export type DTOPipelineListQuery = z.infer<typeof DTOPipelineListQuery>;
+export type DTOPipeline = z.infer<typeof DTOPipeline>;
+export type DTOPipelineResponse = z.infer<typeof DTOPipelineResponse>;
+export type DTOPipelineListResponse = z.infer<typeof DTOPipelineListResponse>;
+export type DTOPipelineExporterQuery = z.infer<typeof DTOPipelineExporterQuery>;
+export type DTOWorkspaceStats = z.infer<typeof DTOWorkspaceStats>;

package/src/api/dto/figma-components/assets/download.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+
+export const DTOAssetRenderConfiguration = z.object({
+  prefix: z.string().optional(),
+  suffix: z.string().optional(),
+  scale: z.enum(["x1", "x2", "x3", "x4"]),
+  format: z.enum(["png", "pdf", "svg"]),
+});
+
+export const DTORenderedAssetFile = z.object({
+  assetId: z.string(),
+  fileName: z.string(),
+  sourceUrl: z.string(),
+  settings: DTOAssetRenderConfiguration,
+  originalName: z.string(),
+});
+
+export const DTODownloadAssetsRequest = z.object({
+  persistentIds: z.array(z.string().uuid()).optional(),
+  settings: DTOAssetRenderConfiguration.array(),
+});
+
+export const DTODownloadAssetsResponse = z.object({
+  items: DTORenderedAssetFile.array(),
+});
+
+export type DTOAssetRenderConfiguration = z.infer<typeof DTOAssetRenderConfiguration>;
+export type DTORenderedAssetFile = z.infer<typeof DTORenderedAssetFile>;
+export type DTODownloadAssetsRequest = z.infer<typeof DTODownloadAssetsRequest>;
+export type DTODownloadAssetsResponse = z.infer<typeof DTODownloadAssetsResponse>;

package/src/api/dto/figma-components/assets/index.ts

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

package/src/api/dto/figma-components/index.ts

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

package/src/api/dto/figma-exporter/figma-node.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+
+export const DTOFigmaExportNodeFormat = z.enum(["HTML", "JSON"]);
+export const DTOFigmaExportNodeConfiguration = z.object({
+  format: DTOFigmaExportNodeFormat,
+  minifyOutput: z.boolean().optional(),
+  customFontUrls: z.string().array().optional(),
+});
+
+export type DTOFigmaExportNodeFormat = z.infer<typeof DTOFigmaExportNodeFormat>;
+export type DTOFigmaExportNodeConfiguration = z.infer<typeof DTOFigmaExportNodeConfiguration>;

package/src/api/dto/figma-exporter/index.ts

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

package/src/api/dto/files/files.ts

@@ -0,0 +1,94 @@
+import z from "zod";
+import {
+  File,
+  FileFigmaRenderMode,
+  FileReference,
+  FileSource,
+  FileSourceUpload,
+  FileSourceFigma,
+} from "@supernova-studio/model";
+
+//
+// Entity
+//
+
+export const DTOFileFigmaRenderMode = FileFigmaRenderMode;
+
+export const DTOFileSourceUpload = FileSourceUpload;
+
+export const DTOFileSourceFigma = FileSourceFigma;
+
+export const DTOFileSource = FileSource;
+
+export const DTOFile = File;
+
+export const DTOFileReference = FileReference;
+
+export type DTOFileFigmaRenderMode = z.infer<typeof DTOFileFigmaRenderMode>;
+export type DTOFileSourceUpload = z.infer<typeof DTOFileSourceUpload>;
+export type DTOFileSourceFigma = z.infer<typeof DTOFileSourceFigma>;
+export type DTOFileSource = z.infer<typeof DTOFileSource>;
+export type DTOFile = z.infer<typeof DTOFile>;
+export type DTOFileReference = z.infer<typeof DTOFileReference>;
+
+//
+// Input Payloads
+//
+
+const DTOFileUploadOwnerUser = z.object({
+  ownerType: z.literal("User"),
+});
+
+const DTOFileUploadOwnerWorkspace = z.object({
+  ownerType: z.literal("Workspace"),
+  workspaceId: z.string(),
+});
+
+const DTOFileUploadOwner = z.discriminatedUnion("ownerType", [DTOFileUploadOwnerUser, DTOFileUploadOwnerWorkspace]);
+
+const DTOFileUploadInput = z.object({
+  size: z.number(),
+  name: z.string(),
+  checksum: z.string(),
+});
+
+export const DTOFileUploadBulkPayload = z
+  .object({
+    files: DTOFileUploadInput.array(),
+  })
+  .and(DTOFileUploadOwner);
+
+export const DTOFileFinalizeBulkPayload = z
+  .object({
+    fileIds: z.string().array(),
+  })
+  .and(DTOFileUploadOwner);
+
+export type DTOFileUploadBulkPayload = z.infer<typeof DTOFileUploadBulkPayload>;
+export type DTOFileFinalizeBulkPayload = z.infer<typeof DTOFileFinalizeBulkPayload>;
+
+//
+// Output Payloads
+//
+
+export const DTOFileListResponse = z.object({
+  files: DTOFile.array(),
+});
+
+export const DTOFileUploadBulkResponse = z.object({
+  files: z.array(DTOFile),
+  uploadUrls: z.array(
+    z.object({
+      fileId: z.string(),
+      uploadUrl: z.string(),
+    })
+  ),
+});
+
+export const DTOFileFinalizeBulkResponse = z.object({
+  files: z.array(DTOFile),
+});
+
+export type DTOFileListResponse = z.infer<typeof DTOFileListResponse>;
+export type DTOFileUploadBulkResponse = z.infer<typeof DTOFileUploadBulkResponse>;
+export type DTOFileFinalizeBulkResponse = z.infer<typeof DTOFileFinalizeBulkResponse>;

package/src/api/dto/files/index.ts

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

package/src/api/dto/forge/agent.ts

@@ -0,0 +1,38 @@
+import { ForgeAgent, ForgeAvatarBuilder } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOForgeAgent = ForgeAgent;
+export const DTOForgeAvatarBuilder = ForgeAvatarBuilder;
+
+export const DTOCreateForgeAgent = DTOForgeAgent.omit({ projectId: true });
+export const DTOUpdateForgeAgent = DTOCreateForgeAgent.extend({ id: z.string() });
+
+export const DTOCreateForgeAgentResponse = z.object({
+  agent: DTOForgeAgent,
+});
+
+export const DTOUGetForgeAgentResponse = z.object({
+  agent: DTOForgeAgent.nullable(),
+});
+
+export const DTOUpdateForgeAgentResponse = z.object({
+  agent: DTOForgeAgent.nullable(),
+});
+
+export const DTOForgeAgentsListResponse = z.object({
+  agents: z.array(DTOForgeAgent),
+});
+
+export const DTODeleteForgeAgentResponse = z.object({
+  ok: z.literal(true),
+});
+
+export type DTOForgeAgent = z.infer<typeof DTOForgeAgent>;
+export type DTPGetForgeAgentResponse = z.infer<typeof DTOUGetForgeAgentResponse>;
+export type DTOForgeAvatarBuilder = z.infer<typeof DTOForgeAvatarBuilder>;
+export type DTOCreateForgeAgent = z.infer<typeof DTOCreateForgeAgent>;
+export type DTOUpdateForgeAgent = z.infer<typeof DTOUpdateForgeAgent>;
+export type DTOCreateForgeAgentResponse = z.infer<typeof DTOCreateForgeAgentResponse>;
+export type DTOUpdateForgeAgentResponse = z.infer<typeof DTOUpdateForgeAgentResponse>;
+export type DTODeleteForgeAgentResponse = z.infer<typeof DTODeleteForgeAgentResponse>;
+export type DTOForgeAgentsListResponse = z.infer<typeof DTOForgeAgentsListResponse>;