@supernova-studio/model 0.59.0 → 0.59.2

package/package.json

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

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

@@ -155,6 +155,16 @@ export type DataSourceVersion = z.infer<typeof DataSourceVersion>;
 
 export type DataSourceRemote = z.infer<typeof DataSourceRemote>;
 export type DataSource = z.infer<typeof DataSource>;
+export type DataSourceOfType<T extends DataSourceRemoteType> = DataSource & {
+  remote: Extract<DataSourceRemote, { type: T }>;
+};
+
+export function isDataSourceOfType<T extends DataSourceRemoteType>(
+  dataSource: DataSource,
+  type: T
+): dataSource is DataSourceOfType<T> {
+  return dataSource.remote.type === type;
+}
 
 export type CreateDataSource = OmitStrict<DbCreateInputOmit<DataSource>, "sortOrder">;
 export type UpdateDataSource = OmitStrict<DbUpdate<DataSource>, "brandPersistentId" | "designSystemId">;

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

@@ -1,27 +1,55 @@
 import { z } from "zod";
+import { nullishToOptional } from "../../../helpers/nullish-to-optional";
 
+//
+// Enums
+//
+
+export const FigmaNodeRenderState = z.enum(["InProgress", "Success", "Failed"]);
 export const FigmaNodeRenderFormat = z.enum(["Png", "Svg"]);
+export const FigmaNodeRenderErrorType = z.enum(["MissingIntegration", "NodeNotFound", "RenderError"]);
 
-export const FigmaNodeReferenceData = z.object({
-  structureElementId: z.string(),
-  nodeId: z.string(),
-  fileId: z.string().optional(),
-  valid: z.boolean(),
-  format: FigmaNodeRenderFormat.default("Png"),
-
-  // Asset data
-  assetId: z.string().optional(),
-  assetScale: z.number().optional(),
-  assetWidth: z.number().optional(),
-  assetHeight: z.number().optional(),
-  assetUrl: z.string().optional(),
-  assetOriginKey: z.string().optional(),
+export type FigmaNodeRenderState = z.infer<typeof FigmaNodeRenderState>;
+export type FigmaNodeRenderFormat = z.infer<typeof FigmaNodeRenderFormat>;
+export type FigmaNodeRenderErrorType = z.infer<typeof FigmaNodeRenderErrorType>;
+
+//
+// Definition
+//
+
+export const FigmaNodeRelinkData = z.object({
+  fileId: z.string(),
 });
 
-export const FigmaNodeReferenceElementData = z.object({
-  value: FigmaNodeReferenceData,
+export const FigmaNodeRenderedImage = z.object({
+  resourceId: z.string(),
+  format: FigmaNodeRenderFormat,
+  scale: nullishToOptional(z.number()),
+
+  width: nullishToOptional(z.number()),
+  height: nullishToOptional(z.number()),
+  url: nullishToOptional(z.string()),
+  originKey: nullishToOptional(z.string()),
 });
 
-export type FigmaNodeRenderFormat = z.infer<typeof FigmaNodeRenderFormat>;
+export const FigmaNodeRenderError = z.object({
+  type: FigmaNodeRenderErrorType,
+});
+
+export const FigmaNodeReferenceData = z.object({
+  sceneNodeId: z.string(),
+  format: FigmaNodeRenderFormat,
+  scale: nullishToOptional(z.number()),
+
+  renderState: FigmaNodeRenderState,
+  renderedImage: FigmaNodeRenderedImage.optional(),
+  renderError: FigmaNodeRenderError.optional(),
+
+  hasSource: z.boolean(),
+  relinkData: FigmaNodeRelinkData.optional(),
+});
+
+export type FigmaNodeRelinkData = z.infer<typeof FigmaNodeRelinkData>;
+export type FigmaNodeRenderedImage = z.infer<typeof FigmaNodeRenderedImage>;
+export type FigmaNodeRenderError = z.infer<typeof FigmaNodeRenderError>;
 export type FigmaNodeReferenceData = z.infer<typeof FigmaNodeReferenceData>;
-export type FigmaNodeReferenceElementData = z.infer<typeof FigmaNodeReferenceElementData>;

package/src/dsm/figma-node-renderer/index.ts

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

package/src/dsm/figma-node-renderer/renderer-payload.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const FigmaNodeRendererPayload = z.object({
+  designSystemId: z.string(),
+  versionId: z.string(),
+  figmaNodePersistentIds: z.string().array(),
+});
+
+export type FigmaNodeRendererPayload = z.infer<typeof FigmaNodeRendererPayload>;

package/src/dsm/index.ts

@@ -4,6 +4,7 @@ export * from "./data-sources";
 export * from "./documentation";
 export * from "./element-snapshots";
 export * from "./elements";
+export * from "./figma-node-renderer";
 export * from "./import";
 export * from "./membership";
 export * from "./properties";

package/src/helpers/db.ts

@@ -1,3 +1,5 @@
+import { OptionalToNullable } from "../utils";
+
 export type DbCreateInputOmit<T> = Omit<T, "id" | "createdAt" | "updatedAt">;
 
 export type DbUpdateInputOmit<T> = Omit<T, "createdAt" | "updatedAt" | "persistentId">;
@@ -5,20 +7,6 @@ export type DbUpdateInputOmit<T> = Omit<T, "createdAt" | "updatedAt" | "persiste
 export type DbUpdate<T extends { id: string }> = Partial<OptionalToNullable<DbUpdateInputOmit<Omit<T, "id">>>> &
   Pick<T, "id">;
 
-type PickOptional<T> = {
-  [P in keyof T as undefined extends T[P] ? P : never]: T[P];
-};
-
-type PickNotOptional<T> = {
-  [P in keyof T as undefined extends T[P] ? never : P]: T[P];
-};
-
-export type OptionalToNullable<T> = {
-  [K in keyof PickOptional<T>]-?: Exclude<T[K], undefined> | null;
-} & {
-  [K in keyof PickNotOptional<T>]: T[K];
-};
-
 export function zodCreateInputOmit() {
   return {
     id: true,
@@ -35,48 +23,3 @@ export function zodUpdateInputOmit() {
     persistentId: true,
   } as const;
 }
-
-// function zodCreate<
-//   T extends ZodRawShape,
-//   UnknownKeys extends UnknownKeysParam = UnknownKeysParam,
-//   Catchall extends ZodTypeAny = ZodTypeAny,
-//   O = objectOutputType<T, Catchall, UnknownKeys>,
-//   I = objectInputType<T, Catchall, UnknownKeys>
-// >(schema: ZodObject<T, UnknownKeysParam, ZodTypeAny, I, O>) {
-//   return schema.omit(zodCreateInputOmit());
-// }
-
-// /**
-//  * Don't use it yet, produces too complex type
-//  */
-// function zodUpdate<
-//   T extends ZodRawShape,
-//   UnknownKeys extends UnknownKeysParam = UnknownKeysParam,
-//   Catchall extends ZodTypeAny = ZodTypeAny,
-//   O = objectOutputType<T, Catchall, UnknownKeys>,
-//   I = objectInputType<T, Catchall, UnknownKeys>
-// >(schema: ZodObject<T, UnknownKeysParam, ZodTypeAny, I, O>) {
-//   const hue = schema.omit(zodUpdateInputOmit());
-//   return makeOptionalPropsNullable(hue).partial();
-// }
-
-// function makeOptionalPropsNullable<Schema extends z.AnyZodObject>(schema: Schema) {
-//   type SchemaType = typeof schema;
-
-//   // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-//   const entries = Object.entries(schema.shape) as [keyof SchemaType["shape"], z.ZodTypeAny][];
-//   const newProps = entries.reduce(
-//     (acc, [key, value]) => {
-//       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-//       acc[key] = value instanceof z.ZodOptional ? value.unwrap().nullable() : value;
-//       return acc;
-//     },
-//     {} as {
-//       [key in keyof SchemaType["shape"]]: SchemaType["shape"][key] extends z.ZodOptional<infer T>
-//         ? z.ZodNullable<T>
-//         : SchemaType["shape"][key];
-//     }
-//   );
-
-//   return z.object(newProps);
-// }

package/src/utils/common.ts

@@ -30,6 +30,20 @@ export type Defined<T> = T extends null | undefined ? never : T;
 // Makes specific properties in the type required
 export type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
 
+type PickOptional<T> = {
+  [P in keyof T as undefined extends T[P] ? P : never]: T[P];
+};
+
+type PickNotOptional<T> = {
+  [P in keyof T as undefined extends T[P] ? never : P]: T[P];
+};
+
+export type OptionalToNullable<T> = {
+  [K in keyof PickOptional<T>]-?: Exclude<T[K], undefined> | null;
+} & {
+  [K in keyof PickNotOptional<T>]: 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");
@@ -172,6 +186,32 @@ export function recordToMap<V>(record: Record<string, V>): Map<string, V> {
   return map;
 }
 
+/**
+ * Applies direct properties from `update` to `object`.
+ *
+ *  - In case a property is not defined in `update`, it `object` will retain the current one
+ *  - In case a property is null in `update`, it will be removed from `object`
+ *
+ * @param object base object to perform updates on
+ * @param update source of property updates
+ * @returns object by merging updates from `update` into `object`
+ */
+export function applyShallowObjectUpdate<T>(object: T, update: Partial<OptionalToNullable<T>>): T {
+  const objectShallowCopy = { ...object };
+
+  for (const [key, value] of Object.entries(update)) {
+    if (value === null) {
+      // @ts-expect-error it's very hard to get typescript to believe that the types will match
+      objectShallowCopy[key] = undefined;
+    } else if (value !== undefined) {
+      // @ts-expect-error it's very hard to get typescript to believe that the types will match
+      objectShallowCopy[key] = value;
+    }
+  }
+
+  return objectShallowCopy;
+}
+
 export type Pagination = {
   skip?: number;
   take?: number;