@supernova-studio/client 0.55.33 → 0.55.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supernova-studio/client",
-  "version": "0.55.33",
+  "version": "0.55.35",
   "description": "Supernova Data Models",
   "source": "src/index.ts",
   "main": "dist/index.js",

package/src/api/dto/design-systems/data-source.ts

@@ -1,14 +1,14 @@
-import { z } from "zod";
 import {
+  DataSourceAutoImportMode,
+  DataSourceFigmaScope,
   DataSourceFigmaState,
   DataSourceRemoteType,
-  DataSourceAutoImportMode,
   DataSourceStats,
-  SourceImportSummary,
-  DataSourceUploadRemoteSource,
   DataSourceUploadImportMetadata,
-  DataSourceFigmaScope,
+  DataSourceUploadRemoteSource,
+  SourceImportSummary,
 } from "@supernova-studio/model";
+import { z } from "zod";
 
 const DTODataSourceFigmaFileVersion = z.object({
   id: z.string(),
@@ -23,7 +23,7 @@ export const DTODataSourceFigmaCloud = z.object({
   autoImportMode: DataSourceAutoImportMode,
   fileThumbnailUrl: z.string().optional(),
   lastImportResult: SourceImportSummary.nullish(),
-  lastImportedAt: z.date().nullish(),
+  lastImportedAt: z.coerce.date().nullish(),
   lastImportedVersion: DTODataSourceFigmaFileVersion.nullish(),
   lastUpdatesCheckedAt: z.date().nullish(),
   ownerId: z.string(),
@@ -40,9 +40,6 @@ export const DTODataSourceFigma = z.object({
   brandId: z.string(),
   themeId: z.string().nullish(),
   cloud: DTODataSourceFigmaCloud.nullish(),
-  tokenStudio: z.literal(null),
-  upload: z.literal(null),
-  figmaVariablesPlugin: z.literal(null),
 });
 
 // TS is not yet implemented in new BE
@@ -52,7 +49,6 @@ export const DTODataSourceTokenStudio = z.object({
   fileName: z.string(),
   brandId: z.string(),
   themeId: z.string().nullish(),
-  cloud: z.literal(null),
   tokenStudio: z.object({
     settings: z.object({
       dryRun: z.boolean(),
@@ -60,7 +56,7 @@ export const DTODataSourceTokenStudio = z.object({
       preciseCopy: z.boolean(),
     }),
     connectionName: z.string(),
-    lastImportedAt: z.date(),
+    lastImportedAt: z.coerce.date(),
     lastImportedResults: z.array(
       z.object({
         mapping: z.object({
@@ -75,8 +71,6 @@ export const DTODataSourceTokenStudio = z.object({
       })
     ),
   }),
-  upload: z.literal(null),
-  figmaVariablesPlugin: z.literal(null),
 });
 
 export const DTODataSourceFigmaVariablesPlugin = z.object({
@@ -84,19 +78,18 @@ export const DTODataSourceFigmaVariablesPlugin = z.object({
   type: z.literal(DataSourceRemoteType.Enum.FigmaVariablesPlugin),
   fileName: z.string(),
   brandId: z.string(),
-  themeId: z.literal(null),
-  cloud: z.literal(null),
-  tokenStudio: z.literal(null),
   upload: z.object({
     remoteId: z.string(),
     remoteSourceType: DataSourceUploadRemoteSource,
-    lastImportedAt: z.date().optional(),
+    lastImportedAt: z.coerce.date().optional(),
     lastImportMetadata: DataSourceUploadImportMetadata.optional(),
+    isTokenTypeSplitEnabled: z.boolean(),
   }),
   figmaVariablesPlugin: z.object({
     fileId: z.string(),
-    lastImportedAt: z.date().optional(),
+    lastImportedAt: z.coerce.date().optional(),
     lastImportMetadata: DataSourceUploadImportMetadata.optional(),
+    isTokenTypeSplitEnabled: z.boolean(),
   }),
 });
 

package/src/api/dto/design-systems/figma-variables.ts

@@ -0,0 +1,107 @@
+import { z } from "zod";
+
+const DimensionsVariableScopeSchema = z.enum([
+  "CORNER_RADIUS",
+  "WIDTH_HEIGHT",
+  "GAP",
+  "STROKE_FLOAT",
+  "EFFECT_FLOAT",
+  "OPACITY",
+  "FONT_SIZE",
+  "LINE_HEIGHT",
+  "LETTER_SPACING",
+  "PARAGRAPH_SPACING",
+  "PARAGRAPH_INDENT",
+]);
+
+const StringVariableScopeSchema = z.enum(["TEXT_CONTENT", "FONT_FAMILY", "FONT_STYLE", "FONT_WEIGHT"]);
+
+export type DimensionsVariableScopeType = z.infer<typeof DimensionsVariableScopeSchema>;
+export const DimensionsVariableScopeType = DimensionsVariableScopeSchema.enum;
+
+export type StringVariableScopeType = z.infer<typeof StringVariableScopeSchema>;
+export const StringVariableScopeType = StringVariableScopeSchema.enum;
+
+const VariableScope = z.string();
+
+const ReferencedVariableOrigin = z.object({
+  name: z.string(),
+  remote: z.boolean(),
+});
+
+export const RGB = z.object({
+  r: z.number(),
+  g: z.number(),
+  b: z.number(),
+});
+
+export const RGBA = RGB.extend({
+  a: z.number(),
+});
+
+export const VariableAlias = z.object({
+  type: z.literal("VARIABLE_ALIAS"),
+  id: z.string(),
+  resolvedValue: z.boolean().or(z.number()).or(z.string()).or(RGBA).or(RGB).optional(),
+  referenceOrigin: ReferencedVariableOrigin.optional().or(z.null()),
+});
+
+export const VariableValue = z.boolean().or(z.number()).or(z.string()).or(RGBA).or(RGB).or(VariableAlias);
+export const ResolvedVariableType = z.enum(["BOOLEAN", "FLOAT", "STRING", "COLOR"]);
+
+export const Variable = z.object({
+  id: z.string(),
+  name: z.string(),
+  key: z.string(),
+  variableCollectionId: z.string(),
+  resolvedType: ResolvedVariableType,
+  valuesByMode: z.record(VariableValue),
+  remote: z.boolean(),
+  description: z.string(),
+  hiddenFromPublishing: z.boolean(),
+  scopes: z.array(VariableScope),
+  codeSyntax: z.record(z.any()).optional(),
+});
+
+export const VariableMode = z.object({
+  modeId: z.string(),
+  name: z.string(),
+});
+
+export const Collection = z.object({
+  id: z.string(),
+  name: z.string(),
+  modes: z.array(VariableMode),
+  defaultModeId: z.string(),
+  remote: z.boolean(),
+  hiddenFromPublishing: z.boolean(),
+});
+
+export const VariablesMapping = z.object({
+  variableCollections: z.array(z.string()).min(1),
+  variableMode: z.string().min(1),
+  supernovaBrand: z.string().min(1),
+  supernovaTheme: z.string().min(1).optional().or(z.null()),
+});
+
+export const FormattedCollections = z.object({
+  variables: z.record(z.string(), Variable),
+  variableCollections: z.record(z.string(), Collection),
+  mappings: z.array(VariablesMapping).optional(),
+  variablesOrder: z.string().array().optional(),
+});
+
+//
+// Types
+//
+
+export type RGB = z.infer<typeof RGB>;
+export type RGBA = z.infer<typeof RGBA>;
+export type ResolvedVariableType = z.infer<typeof ResolvedVariableType>;
+export type Variable = z.infer<typeof Variable>;
+export type VariableAlias = z.infer<typeof VariableAlias>;
+export type VariableValue = z.infer<typeof VariableValue>;
+export type VariableMode = z.infer<typeof VariableMode>;
+export type Collection = z.infer<typeof Collection>;
+export type VariablesMapping = z.infer<typeof VariablesMapping>;
+export type FormattedCollections = z.infer<typeof FormattedCollections>;

package/src/api/dto/design-systems/import-job.ts

@@ -0,0 +1,61 @@
+import {
+  DataSourceAutoImportMode,
+  DataSourceFigmaScope,
+  DataSourceRemoteType,
+  ImportJobState,
+} from "@supernova-studio/model";
+import { z } from "zod";
+
+//
+// Read
+//
+
+export const DTOImportJob = z.object({
+  id: z.string(),
+  designSystemId: z.string(),
+  designSystemVersionId: z.string(),
+  operation: z.literal("Import"),
+  createdAt: z.coerce.date(),
+  stateChangedAt: z.coerce.date(),
+  state: ImportJobState,
+  sourceIds: z.string().array(),
+});
+
+export const DTOImportJobResponse = z.object({
+  job: DTOImportJob,
+});
+
+export type DTOImportJob = z.infer<typeof DTOImportJob>;
+export type DTOImportJobResponse = z.infer<typeof DTOImportJobResponse>;
+
+//
+// Write
+//
+
+export const DTOBffFigmaImportRequestBody = z.object({
+  type: z.literal(DataSourceRemoteType.Enum.Figma),
+  brandPersistentId: z.string().optional(),
+  fileId: z.string(),
+  scope: DataSourceFigmaScope,
+  autoImportMode: DataSourceAutoImportMode,
+});
+
+export const DTOBffUploadImportRequestBody = z.object({
+  type: z
+    .enum([DataSourceRemoteType.Enum.FigmaVariablesPlugin, "Upload"])
+    .transform(v => DataSourceRemoteType.Enum.FigmaVariablesPlugin),
+  brandPersistentId: z.string().optional(),
+  sourceName: z.string().optional(),
+  remoteId: z.string(),
+  isTokenTypeSplitEnabled: z.boolean().optional(),
+  payload: z.any(),
+});
+
+export const DTOBffImportRequestBody = z.discriminatedUnion("type", [
+  DTOBffFigmaImportRequestBody,
+  DTOBffUploadImportRequestBody,
+]);
+
+export type DTOBffFigmaImportRequestBody = z.infer<typeof DTOBffFigmaImportRequestBody>;
+export type DTOBffUploadImportRequestBody = z.infer<typeof DTOBffUploadImportRequestBody>;
+export type DTOBffImportRequestBody = z.infer<typeof DTOBffImportRequestBody>;

package/src/api/dto/design-systems/index.ts

@@ -3,6 +3,8 @@ export * from "./data-source";
 export * from "./design-system";
 export * from "./elements-diff";
 export * from "./exporter-property";
+export * from "./figma-variables";
+export * from "./import-job";
 export * from "./members";
 export * from "./role";
 export * from "./stats";

package/src/api/dto/design-tokens/design-token.ts

@@ -0,0 +1,21 @@
+import { DesignTokenOrigin, DesignTokenTypedData, ObjectMeta } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTODesignToken = DesignTokenTypedData.and(
+  z.object({
+    id: z.string(),
+    persistentId: z.string(),
+    designSystemVersionId: z.string(),
+    meta: ObjectMeta,
+    origin: DesignTokenOrigin.optional(),
+    brandId: z.string(),
+    updatedAt: z.coerce.date(),
+  })
+);
+
+export const DTODesignTokenListResponse = z.object({
+  tokens: DTODesignToken.array(),
+});
+
+export type DTODesignToken = z.infer<typeof DTODesignToken>;
+export type DTODesignTokenListResponse = z.infer<typeof DTODesignTokenListResponse>;

package/src/api/dto/design-tokens/index.ts

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

package/src/api/dto/index.ts

@@ -2,6 +2,7 @@ export * from "./aux";
 export * from "./bff";
 export * from "./collections";
 export * from "./design-systems";
+export * from "./design-tokens";
 export * from "./documentation";
 export * from "./elements";
 export * from "./export";

package/src/api/endpoints/design-system/bff.ts

@@ -0,0 +1,13 @@
+import { DTOBffImportRequestBody, DTOImportJobResponse } from "../../dto";
+import { RequestExecutor } from "../../transport/request-executor";
+
+export class DesignSystemBffEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  import(dsId: string, payload: DTOBffImportRequestBody) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/bff/import`, DTOImportJobResponse, {
+      method: "POST",
+      body: payload,
+    });
+  }
+}

package/src/api/endpoints/design-system/design-systems.ts

@@ -2,17 +2,22 @@ import { z } from "zod";
 import { DTODesignSystemCreateInput, DTODesignSystemResponse, DTODesignSystemsListResponse } from "../../dto";
 import { DTODesignSystemUpdateAccessModeInput, DTODesignSystemUpdateInput } from "../../payloads";
 import { RequestExecutor } from "../../transport/request-executor";
-import { DesignSystemMembersEndpoint } from "./design-system-members";
-import { DesignSystemVersionsEndpoint } from "./design-system-versions";
-import { TokensEndpoint } from "./versions";
+import { DesignSystemBffEndpoint } from "./bff";
+import { DesignSystemMembersEndpoint } from "./members";
+import { DesignSystemSourcesEndpoint } from "./sources";
+import { DesignSystemVersionsEndpoint } from "./versions";
 
 export class DesignSystemsEndpoint {
   readonly members: DesignSystemMembersEndpoint;
   readonly versions: DesignSystemVersionsEndpoint;
+  readonly bff: DesignSystemBffEndpoint;
+  readonly sources: DesignSystemSourcesEndpoint;
 
   constructor(private readonly requestExecutor: RequestExecutor) {
     this.members = new DesignSystemMembersEndpoint(requestExecutor);
     this.versions = new DesignSystemVersionsEndpoint(requestExecutor);
+    this.bff = new DesignSystemBffEndpoint(requestExecutor);
+    this.sources = new DesignSystemSourcesEndpoint(requestExecutor);
   }
 
   create(body: DTODesignSystemCreateInput) {

package/src/api/endpoints/design-system/index.ts

@@ -1,4 +1,6 @@
 export * from "./versions";
-export * from "./design-system-members";
-export * from "./design-system-versions";
+export * from "./bff";
 export * from "./design-systems";
+export * from "./members";
+export * from "./sources";
+export * from "./versions";

package/src/api/endpoints/design-system/sources.ts

@@ -0,0 +1,10 @@
+import { DTODataSourcesListResponse } from "../../dto";
+import { RequestExecutor } from "../../transport/request-executor";
+
+export class DesignSystemSourcesEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  list(dsId: string) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/sources`, DTODataSourcesListResponse);
+  }
+}

package/src/api/endpoints/design-system/versions/brands.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { DTOBrandGetResponse, DTOBrandsListResponse } from "../../../dto";
 import { RequestExecutor } from "../../../transport/request-executor";
 
 export class BrandsEndpoint {
@@ -7,11 +7,14 @@ export class BrandsEndpoint {
   get(designSystemId: string, versionId: string, brandId: string) {
     return this.requestExecutor.json(
       `/design-systems/${designSystemId}/versions/${versionId}/brands/${brandId}`,
-      z.any()
+      DTOBrandGetResponse
     );
   }
 
   list(designSystemId: string, versionId: string) {
-    return this.requestExecutor.json(`/design-systems/${designSystemId}/versions/${versionId}/brands`, z.any());
+    return this.requestExecutor.json(
+      `/design-systems/${designSystemId}/versions/${versionId}/brands`,
+      DTOBrandsListResponse
+    );
   }
 }

package/src/api/endpoints/design-system/versions/import-jobs.ts

@@ -0,0 +1,13 @@
+import { DTOImportJobResponse } from "../../../dto";
+import { RequestExecutor } from "../../../transport/request-executor";
+
+export class ImportJobsEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  get(designSystemId: string, versionId: string, jobId: string) {
+    return this.requestExecutor.json(
+      `/design-systems/${designSystemId}/versions/${versionId}/import-jobs/${jobId}`,
+      DTOImportJobResponse
+    );
+  }
+}

package/src/api/endpoints/design-system/versions/index.ts

@@ -1,4 +1,5 @@
 export * from "./brands";
+export * from "./import-jobs";
 export * from "./overrides";
 export * from "./stats";
 export * from "./themes";

package/src/api/endpoints/design-system/versions/tokens.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DTODesignTokenListResponse } from "../../../dto";
 import { RequestExecutor } from "../../../transport/request-executor";
 
 export class TokensEndpoint {
@@ -10,4 +11,11 @@ export class TokensEndpoint {
       body,
     });
   }
+
+  list(dsId: string, versionId: string): Promise<DTODesignTokenListResponse> {
+    return this.requestExecutor.json(
+      `/design-systems/${dsId}/versions/${versionId}/tokens`,
+      DTODesignTokenListResponse
+    );
+  }
 }

package/src/api/endpoints/design-system/{design-system-versions.ts → versions.ts}

@@ -1,18 +1,22 @@
 import { DTODesignSystemVersionsListResponse } from "../../dto";
 import { RequestExecutor } from "../../transport/request-executor";
-import { TokensEndpoint, VersionStatsEndpoint } from "./versions";
 import { BrandsEndpoint } from "./versions/brands";
+import { ImportJobsEndpoint } from "./versions/import-jobs";
+import { VersionStatsEndpoint } from "./versions/stats";
 import { ThemesEndpoint } from "./versions/themes";
+import { TokensEndpoint } from "./versions/tokens";
 
 export class DesignSystemVersionsEndpoint {
   readonly themes: ThemesEndpoint;
   readonly brands: BrandsEndpoint;
+  readonly importJobs: ImportJobsEndpoint;
   readonly tokens: TokensEndpoint;
   readonly stats: VersionStatsEndpoint;
 
   constructor(private readonly requestExecutor: RequestExecutor) {
     this.themes = new ThemesEndpoint(requestExecutor);
     this.brands = new BrandsEndpoint(requestExecutor);
+    this.importJobs = new ImportJobsEndpoint(requestExecutor);
     this.tokens = new TokensEndpoint(requestExecutor);
     this.stats = new VersionStatsEndpoint(requestExecutor);
   }