@supernova-studio/model 0.16.0 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supernova-studio/model",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Supernova Data Models",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/dsm/assets/asset.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { OmitStrict } from "../../helpers";
+import { OmitStrict } from "../../utils";
 
 export const AssetType = z.enum(["Image", "Font"]);
 export const AssetScope = z.enum(["DocumentationFrame", "ComponentThumbnail", "DesignSystem", "Documentation"]);

package/src/dsm/data-sources/data-source.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { SourceImportSummary } from "./import-summary";
-import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { DbCreateInputOmit, DbUpdate } from "../../helpers";
+import { OmitStrict } from "../../utils";
 
 //
 // Enums

package/src/dsm/data-sources/import-job.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { DbCreateInputOmit, DbUpdate } from "../../helpers";
+import { OmitStrict } from "../../utils";
 import { DataSourceRemoteType } from "./data-source";
 import { Entity } from "../../common";
 

package/src/dsm/elements/component.ts

@@ -1,4 +1,5 @@
-import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { DbCreateInputOmit, DbUpdate } from "../../helpers";
+import { OmitStrict } from "../../utils";
 import { z } from "zod";
 import {
   DesignElementBase,

package/src/dsm/elements/data/documentation-block-v2.ts

@@ -155,6 +155,13 @@ export const PageBlockItemEmbedValue = z.object({
   value: z.string().optional(),
   caption: z.string().optional(),
   height: z.number().optional(),
+  openGraph: z
+    .object({
+      title: z.string().optional(),
+      description: z.string().optional(),
+      imageUrl: z.string().optional(),
+    })
+    .optional(),
 });
 
 export const PageBlockItemFigmaNodeValue = z.object({

package/src/dsm/elements/documentation-page-v1.ts

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import { DesignElementBase, DesignElementGroupableRequiredPart, DesignElementSlugPart } from "./base";
 import { DocumentationPageDataV1 } from "./data";
-import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { DbCreateInputOmit, DbUpdate } from "../../helpers";
+import { OmitStrict } from "../../utils";
 
 export const DocumentationPageV1 = DesignElementBase.extend(DesignElementGroupableRequiredPart.shape)
   .extend(DesignElementSlugPart.shape)

package/src/dsm/elements/documentation-page-v2.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { DesignElementBase, DesignElementGroupableRequiredPart, DesignElementSlugPart } from "./base";
-import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { DbCreateInputOmit, DbUpdate } from "../../helpers";
+import { OmitStrict } from "../../utils";
 import { DocumentationPageDataV2 } from "./data/documentation-page-v2";
 
 export const DocumentationPageV2 = DesignElementBase.extend(DesignElementGroupableRequiredPart.shape)

package/src/dsm/elements/figma-file-structures.ts

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import { DesignElementBase } from "./base";
 import { FigmaFileStructureNode, FigmaFileStructureStatistics } from "./data/figma-file-structure";
-import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { DbCreateInputOmit, DbUpdate } from "../../helpers";
+import { OmitStrict } from "../../utils";
 
 export const FigmaFileStructureOrigin = z.object({
   sourceId: z.string(),

package/src/dsm/elements/figma-node-reference.ts

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import { DesignElementBase } from "./base";
 import { FigmaNodeReferenceData } from "./data/figma-node-reference";
-import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { DbCreateInputOmit, DbUpdate } from "../../helpers";
+import { OmitStrict } from "../../utils";
 
 export const FigmaNodeReference = DesignElementBase.extend({
   data: FigmaNodeReferenceData,

package/src/dsm/elements/group.ts

@@ -2,9 +2,8 @@ import { DesignElementType } from "./raw-element";
 import { DesignElementBase, DesignElementBrandedPart, DesignElementGroupablePart, DesignElementSlugPart } from "./base";
 import { z } from "zod";
 import { DbCreateInputOmit, DbUpdate } from "../../helpers";
-import { OmitStrict } from "../../helpers";
-import { DocumentationGroupBehavior, ElementGroupData } from "./data";
-import { DocumentationItemConfiguration } from "./data";
+import { OmitStrict } from "../../utils";
+import { ElementGroupData } from "./data";
 
 export const ElementGroup = DesignElementBase.extend(DesignElementGroupablePart.shape)
   .extend(DesignElementSlugPart.shape)

package/src/dsm/elements/raw-element.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { DbCreateInputOmit, DbUpdate } from "../../helpers";
+import { OmitStrict } from "../../utils";
 import { ObjectMeta } from "../../common";
 
 export type CreateDesignElement = DbCreateInputOmit<DesignElement>;

package/src/dsm/elements/theme.ts

@@ -2,7 +2,8 @@ import { z } from "zod";
 import { DesignTokenOrigin, DesignTokenOriginPart, DesignTokenTypedData } from "./tokens";
 import { DesignTokenType } from "./raw-element";
 import { DesignElementBase, DesignElementBrandedPart } from "./base";
-import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { DbCreateInputOmit, DbUpdate } from "../../helpers";
+import { OmitStrict } from "../../utils";
 
 //
 // Overrides

package/src/dsm/elements/tokens.ts

@@ -5,7 +5,8 @@ import {
   DesignElementGroupableRequiredPart,
   DesignElementOrigin,
 } from "./base";
-import { DbUpdate, OmitStrict, zodCreateInputOmit, zodUpdateInputOmit } from "../../helpers";
+import { DbUpdate, zodCreateInputOmit, zodUpdateInputOmit } from "../../helpers";
+import { OmitStrict } from "../../utils";
 import { DesignTokenType } from "./raw-element";
 import {
   TextCaseTokenData,

package/src/dsm/properties/property-value.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { DbCreateInputOmit, DbUpdate } from "../../helpers";
+import { OmitStrict } from "../../utils";
 
 export const ElementPropertyValue = z.object({
   id: z.string(),

package/src/dsm/published-doc-page.ts

@@ -1,4 +1,5 @@
-import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../helpers";
+import { DbCreateInputOmit, DbUpdate } from "../helpers";
+import { OmitStrict } from "../utils";
 
 export const SHORT_PERSISTENT_ID_LENGTH = 8;
 

package/src/dsm/views/column.ts

@@ -1,4 +1,5 @@
-import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { DbCreateInputOmit, DbUpdate } from "../../helpers";
+import { OmitStrict } from "../../utils";
 
 export type ElementViewBaseColumnType = "Name" | "Description" | "Value" | "UpdatedAt";
 

package/src/helpers/index.ts

@@ -1,3 +1,2 @@
-export * from "./common";
 export * from "./db";
 export * from "./nullish-to-optional";

package/src/multiplayer/design-system-version-room.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { Entity } from "../common/entity";
 import { DbCreateInputOmit, DbUpdate } from "../helpers";
+import { DocumentationPageV2, ElementGroup } from "../dsm";
 
 export const DesignSystemVersionRoom = Entity.extend({
   designSystemVersionId: z.string(),
@@ -11,3 +12,20 @@ export type DesignSystemVersionRoom = z.infer<typeof DesignSystemVersionRoom>;
 
 export type CreateDesignSystemVersionRoom = DbCreateInputOmit<DesignSystemVersionRoom>;
 export type UpdateDesignSystemVersionRoom = DbUpdate<DesignSystemVersionRoom>;
+
+//
+// Update
+//
+
+export const DesignSystemVersionRoomInitialState = z.object({
+  pages: z.array(DocumentationPageV2),
+  groups: z.array(ElementGroup),
+});
+
+export const DesignSystemVersionRoomUpdate = DesignSystemVersionRoomInitialState.extend({
+  deletedPageIds: z.array(z.string()),
+  deletedGroupIds: z.array(z.string()),
+});
+
+export type DesignSystemVersionRoomInitialState = z.infer<typeof DesignSystemVersionRoomInitialState>;
+export type DesignSystemVersionRoomUpdate = z.infer<typeof DesignSystemVersionRoomUpdate>;

package/src/multiplayer/documentation-page-room.ts

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { Entity } from "../common/entity";
 import { DbCreateInputOmit, DbUpdate } from "../helpers";
+import { DocumentationPageV2, ElementGroup, PageBlockDefinition } from "../dsm";
+import { PageBlockEditorModel } from "@supernova-studio/client";
 
 export const DocumentationPageRoom = Entity.extend({
   designSystemVersionId: z.string(),
@@ -12,3 +14,20 @@ export type DocumentationPageRoom = z.infer<typeof DocumentationPageRoom>;
 
 export type CreateDocumentationPageRoom = DbCreateInputOmit<DocumentationPageRoom>;
 export type UpdateDocumentationPageRoom = DbUpdate<DocumentationPageRoom>;
+
+//
+// Room content
+//
+
+export const DocumentationPageRoomRoomUpdate = z.object({
+  page: DocumentationPageV2,
+  pageParent: ElementGroup,
+});
+
+export const DocumentationPageRoomInitialState = DocumentationPageRoomRoomUpdate.extend({
+  pageBlocks: z.array(PageBlockEditorModel),
+  blockDefinitions: z.array(PageBlockDefinition),
+});
+
+export type DocumentationPageRoomRoomUpdate = z.infer<typeof DocumentationPageRoomRoomUpdate>;
+export type DocumentationPageRoomInitialState = z.infer<typeof DocumentationPageRoomInitialState>;

package/src/utils/common.ts

@@ -0,0 +1,111 @@
+import { SupernovaException } from "./errors";
+
+export type OmitStrict<T, K extends keyof T> = T extends any ? Pick<T, Exclude<keyof T, K>> : never;
+
+export type Nullish<T> = T | null | undefined;
+
+export type ExplicitPartial<T> = { [P in keyof T]: T[P] | undefined };
+
+// Magic as far as I'm concerned.
+// Taken from https://stackoverflow.com/a/50375286/3229534
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+// This utility lets T be indexed by any key
+type Indexify<T> = T & { [str: string]: undefined };
+
+// To make a type where all values are undefined, so that in AllUnionKeys<T>
+// TS doesn't remove the keys whose values are incompatible, e.g. string & number
+type UndefinedVals<T> = { [K in keyof T]: undefined };
+
+// This returns a union of all keys present across all members of the union T
+type AllUnionKeys<T> = keyof UnionToIntersection<UndefinedVals<T>>;
+
+// Where the (rest of the) magic happens ✨
+export type AllFields<T> = { [K in AllUnionKeys<T> & string]: Indexify<T>[K] };
+
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+
+export function forceUnwrapNullish<T>(value: Nullish<T>): T {
+  if (value === null) throw new Error("Illegal null");
+  if (value === undefined) throw new Error("Illegal undefined");
+  return value;
+}
+
+export function trimLeadingSlash(string: string): string {
+  return string.startsWith("/") ? string.substring(1) : string;
+}
+
+export function trimTrailingSlash(string: string): string {
+  return string.endsWith("/") ? string.substring(0, string.length - 1) : string;
+}
+
+export function parseUrl(url: string): URL {
+  return new URL(url.startsWith("https://") || url.startsWith("http://") ? url : `https://${url}`);
+}
+
+export function mapByUnique<V, K>(items: V[], keyFn: (item: V) => K): Map<K, V> {
+  const result = new Map<K, V>();
+  for (const item of items) {
+    result.set(keyFn(item), item);
+  }
+  return result;
+}
+
+export function groupBy<V, K>(items: V[], keyFn: (item: V) => K): Map<K, V[]> {
+  const result = new Map<K, V[]>();
+
+  for (const item of items) {
+    const key = keyFn(item);
+    const array = result.get(key);
+    if (array) {
+      array.push(item);
+    } else {
+      result.set(key, [item]);
+    }
+  }
+
+  return result;
+}
+
+export function filterNonNullish<T>(items: Nullish<T>[]): T[] {
+  return items.filter(Boolean) as T[];
+}
+
+export function nonNullishFilter<T>(item: Nullish<T>): item is T {
+  return !!item;
+}
+
+export function nonNullFilter<T>(item: T | null): item is T {
+  return item !== null;
+}
+
+export type ArrayElementType<T extends Default[], Default = any> = T extends (infer U)[] ? U : Default;
+
+export function buildConstantEnum<Inferred extends ArrayElementType<Passed>[], Passed extends string[]>(
+  values: Inferred
+): { [key in Inferred[number]]: key } {
+  const constMap = values.reduce((acc, code) => ({ ...acc, [code]: code }), {});
+
+  return constMap as { [key in Inferred[number]]: key };
+}
+
+export async function promiseWithTimeout<T>(timeoutMs: number, promise: () => Promise<T>): Promise<T> {
+  let timeoutHandle: NodeJS.Timeout | undefined;
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeoutHandle = setTimeout(() => reject(SupernovaException.timeout()), timeoutMs);
+  });
+
+  const result = await Promise.race([promise(), timeoutPromise]);
+
+  clearTimeout(timeoutHandle);
+  return result;
+}
+
+export async function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export type Pagination = {
+  skip?: number;
+  take?: number;
+};

package/src/utils/errors.ts

@@ -0,0 +1,94 @@
+export type SupernovaExceptionType =
+  | "AccessDenied"
+  | "ResourceNotFound"
+  | "WrongFormat"
+  | "Timeout"
+  | "Conflict"
+  | "NotImplemented"
+  | "BadRequest"
+  | "WrongActionOrder"
+  | "InvalidOperation"
+  | "UnexpectedError"
+  | "IPRestricted"
+  | "PlanRestricted"
+  | "MissingWorkspacePermission"
+  | "MissingExporterPermission"
+  | "NoAccess";
+
+export class SupernovaException extends Error {
+  static wrongFormat(message?: string): SupernovaException {
+    return new SupernovaException("WrongFormat", message);
+  }
+
+  static accessDenied(message?: string): SupernovaException {
+    return new SupernovaException("AccessDenied", message);
+  }
+
+  static notFound(message?: string): SupernovaException {
+    return new SupernovaException("ResourceNotFound", message);
+  }
+
+  static timeout(message?: string): SupernovaException {
+    return new SupernovaException("Timeout", message);
+  }
+
+  static conflict(message?: string): SupernovaException {
+    return new SupernovaException("Conflict", message);
+  }
+
+  static notImplemented(message?: string): SupernovaException {
+    return new SupernovaException("NotImplemented", message);
+  }
+
+  static wrongActionOrder(message?: string): SupernovaException {
+    return new SupernovaException("WrongActionOrder", message);
+  }
+
+  static invalidOperation(message?: string): SupernovaException {
+    return new SupernovaException("InvalidOperation", message);
+  }
+
+  static shouldNotHappen(message?: string): SupernovaException {
+    return new SupernovaException("UnexpectedError", message);
+  }
+
+  static ipRestricted(message?: string): SupernovaException {
+    return new SupernovaException("IPRestricted", message);
+  }
+
+  static planRestricted(message?: string): SupernovaException {
+    return new SupernovaException("PlanRestricted", message);
+  }
+
+  static missingWorkspacePermission(message?: string): SupernovaException {
+    return new SupernovaException("MissingWorkspacePermission", message);
+  }
+
+  static missingExporterPermission(message?: string): SupernovaException {
+    return new SupernovaException("MissingExporterPermission", message);
+  }
+
+  static missingIntegration(message?: string): SupernovaException {
+    return new SupernovaException("AccessDenied", message);
+  }
+
+  static noAccess(message?: string): SupernovaException {
+    return new SupernovaException("NoAccess", message);
+  }
+
+  //
+  // To refactor
+  //
+
+  static badRequest(message?: string): SupernovaException {
+    return new SupernovaException("BadRequest", message);
+  }
+
+  //
+  // Properties
+  //
+
+  constructor(readonly type: SupernovaExceptionType, message?: string) {
+    super(`${type}: ${message}`);
+  }
+}

package/src/utils/index.ts

@@ -1,2 +1,5 @@
+export * from "./common";
 export * from "./content-loader-instruction";
+export * from "./errors";
+export * from "./slugify";
 export * from "./validation";