@supernova-studio/model 0.0.4

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

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { Entity } from "../common/entity";
+import { DbCreateInputOmit, DbUpdate } from "../helpers";
+
+export const DocumentationPageRoom = Entity.extend({
+  designSystemVersionId: z.string(),
+  documentationPageId: z.string(),
+  liveblocksId: z.string(),
+});
+
+export type DocumentationPageRoom = z.infer<typeof DocumentationPageRoom>;
+
+export type CreateDocumentationPageRoom = DbCreateInputOmit<DocumentationPageRoom>;
+export type UpdateDocumentationPageRoom = DbUpdate<DocumentationPageRoom>;

package/src/multiplayer/index.ts

@@ -0,0 +1,2 @@
+export * from "./design-system-version-room";
+export * from "./documentation-page-room";

package/src/npm/index.ts

@@ -0,0 +1,2 @@
+export * from "./npm-package";
+export * from "./npm-proxy-token-payload";

package/src/npm/npm-package.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+
+const AnyRecord = z.record(z.any());
+
+const NpmPackageVersionDist = AnyRecord.and(
+  z.object({
+    tarball: z.string(),
+  })
+);
+
+const NpmPackageVersion = AnyRecord.and(
+  z.object({
+    dist: NpmPackageVersionDist,
+  })
+);
+
+export const NpmPackage = AnyRecord.and(
+  z.object({
+    _id: z.string(),
+    name: z.string(),
+
+    // e.g. "latest": "1.2.3"
+    "dist-tags": z.record(z.string(), z.string()),
+
+    // "1.2.3": {...}
+    versions: z.record(NpmPackageVersion),
+  })
+);
+
+export type NpmPackage = z.infer<typeof NpmPackage>;

package/src/npm/npm-proxy-token-payload.ts

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

package/src/tokens/index.ts

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

package/src/tokens/personal-access-token.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { WorkspaceRoleSchema } from "../workspace";
+
+export const PersonalAccessToken = z.object({
+  id: z.string(),
+  userId: z.string(),
+  name: z.string(),
+  token: z.string(),
+  createdAt: z.date(),
+  hidden: z.boolean(),
+  workspaceId: z.string().optional(),
+  workspaceRole: WorkspaceRoleSchema.optional(),
+  expireAt: z.date().optional(),
+  scope: z.string().optional(),
+});
+
+export type PersonalAccessToken = z.infer<typeof PersonalAccessToken>;

package/src/users/index.ts

@@ -0,0 +1,5 @@
+export * from "./linked-integrations";
+export * from "./user-identity";
+export * from "./user-profile";
+export * from "./user-with-pat";
+export * from "./user";

package/src/users/linked-integrations.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+
+export const IntegrationAuthType = z.union([z.literal("OAuth2"), z.literal("PAT")]);
+
+export type IntegrationAuthType = z.infer<typeof IntegrationAuthType>;
+
+export const ExternalServiceType = z.union([
+  z.literal("figma"),
+  z.literal("github"),
+  z.literal("azure"),
+  z.literal("gitlab"),
+  z.literal("bitbucket"),
+]);
+
+export type ExternalServiceType = z.infer<typeof ExternalServiceType>;
+
+export const IntegrationUserInfo = z.object({
+  id: z.string(),
+  handle: z.string().optional(),
+  avatarUrl: z.string().optional(),
+  email: z.string().optional(),
+  authType: IntegrationAuthType.optional(),
+  customUrl: z.string().optional(),
+});
+
+export type IntegrationUserInfo = z.infer<typeof IntegrationUserInfo>;
+
+export const UserLinkedIntegrations = z.object({
+  figma: IntegrationUserInfo.optional(),
+  github: IntegrationUserInfo.array().optional(),
+  azure: IntegrationUserInfo.array().optional(),
+  gitlab: IntegrationUserInfo.array().optional(),
+  bitbucket: IntegrationUserInfo.array().optional(),
+});
+
+export type UserLinkedIntegrations = z.infer<typeof UserLinkedIntegrations>;

package/src/users/user-identity.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+export const UserIdentity = z.object({
+  id: z.string(),
+  userId: z.string(),
+});
+
+export type UserIdentity = z.infer<typeof UserIdentity>;

package/src/users/user-profile.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+
+export const UserOnboardingDepartment = z.enum(["Design", "Engineering", "Brand", "Other"]);
+
+export const UserOnboardingJobLevel = z.enum(["Executive", "Manager", "IndividualContributor", "Other"]);
+
+export const UserOnboarding = z.object({
+  companyName: z.string().optional(),
+  numberOfPeopleInOrg: z.string().optional(),
+  numberOfPeopleInDesignTeam: z.string().optional(),
+  department: UserOnboardingDepartment.optional(),
+  jobTitle: z.string().optional(),
+  phase: z.string().optional(),
+  jobLevel: UserOnboardingJobLevel.optional(),
+});
+
+export type UserOnboarding = z.infer<typeof UserOnboarding>;
+
+export const UserProfile = z.object({
+  name: z.string(),
+  avatar: z.string().optional(),
+  nickname: z.string().optional(),
+  onboarding: UserOnboarding.optional(),
+});
+
+export type UserProfile = z.infer<typeof UserProfile>;

package/src/users/user-with-pat.ts

@@ -0,0 +1,7 @@
+import { User } from "./user";
+import { PersonalAccessToken } from "../tokens";
+
+export type PersonalAccessTokenWithUser = {
+  user: User;
+  token: PersonalAccessToken;
+};

package/src/users/user.ts

@@ -0,0 +1,17 @@
+import { UserLinkedIntegrations } from "./linked-integrations";
+import { UserProfile } from "./user-profile";
+import { z } from "zod";
+
+export const User = z.object({
+  id: z.string(),
+  email: z.string(),
+  emailVerified: z.boolean(),
+  createdAt: z.date(),
+  trialExpiresAt: z.date().optional(),
+  profile: UserProfile,
+  linkedIntegrations: UserLinkedIntegrations.optional(),
+  loggedOutAt: z.date().optional(),
+  isProtected: z.boolean(),
+});
+
+export type User = z.infer<typeof User>;

package/src/utils/content-loader-instruction.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+
+export const ContentLoadInstruction = z.object({
+  from: z.string(),
+  to: z.string(),
+  authorizationHeaderKvsId: z.string().optional(),
+  timeout: z.number().optional(),
+});
+
+export type ContentLoadInstruction = z.infer<typeof ContentLoadInstruction>;
+
+export const ContentLoaderPayload = z
+  .object({
+    type: z.literal("Single"),
+    instruction: ContentLoadInstruction,
+  })
+  .or(
+    z.object({
+      type: z.literal("Multiple"),
+      loadingChunkSize: z.number().optional(),
+      instructions: z.array(ContentLoadInstruction),
+    })
+  )
+  .or(
+    z.object({
+      type: z.literal("S3"),
+      location: z.string(),
+    })
+  );
+
+export type ContentLoaderPayload = z.infer<typeof ContentLoaderPayload>;

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from "./content-loader-instruction";

package/src/workspace/index.ts

@@ -0,0 +1,9 @@
+export * from "./npm-registry-settings";
+export * from "./sso-provider";
+export * from "./user-invite";
+export * from "./workspace-context";
+export * from "./workspace-create";
+export * from "./workspace-invitations";
+export * from "./workspace-membership";
+export * from "./workspace-role";
+export * from "./workspace";

package/src/workspace/npm-registry-settings.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+
+export const NpmRegistryAuthType = z.enum(["Basic", "Bearer", "None", "Custom"]);
+export const NpmRegistryType = z.enum(["NPMJS", "GitHub", "AzureDevOps", "Artifactory", "Custom"]);
+
+export const NpmRegistryBasicAuthConfig = z.object({
+  authType: z.literal(NpmRegistryAuthType.Enum.Basic),
+  username: z.string(),
+  password: z.string(),
+});
+
+export const NpmRegistryBearerAuthConfig = z.object({
+  authType: z.literal(NpmRegistryAuthType.Enum.Bearer),
+  accessToken: z.string(),
+});
+
+export const NpmRegistryNoAuthConfig = z.object({
+  authType: z.literal(NpmRegistryAuthType.Enum.None),
+});
+
+export const NpmRegistrCustomAuthConfig = z.object({
+  authType: z.literal(NpmRegistryAuthType.Enum.Custom),
+  authHeaderName: z.string(),
+  authHeaderValue: z.string(),
+});
+
+export const NpmRegistryAuthConfig = z.discriminatedUnion("authType", [
+  NpmRegistryBasicAuthConfig,
+  NpmRegistryBearerAuthConfig,
+  NpmRegistryNoAuthConfig,
+  NpmRegistrCustomAuthConfig,
+]);
+
+const NpmRegistryConfigBase = z.object({
+  registryType: NpmRegistryType,
+  enabledScopes: z.array(z.string()),
+  customRegistryUrl: z.string().optional(),
+  bypassProxy: z.boolean().default(false),
+  npmProxyRegistryConfigId: z.string().optional(),
+  npmProxyVersion: z.number().optional(),
+});
+
+export const NpmRegistryConfig = NpmRegistryConfigBase.and(NpmRegistryAuthConfig);
+
+export type NpmRegistryConfig = z.infer<typeof NpmRegistryConfig>;

package/src/workspace/sso-provider.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export const SsoProvider = z.object({
+  providerId: z.string(),
+  defaultAutoInviteValue: z.boolean(),
+  autoInviteDomains: z.record(z.string(), z.boolean()),
+  skipDocsSupernovaLogin: z.boolean(),
+  areInvitesDisabled: z.boolean(),
+  isTestMode: z.boolean(),
+  emailDomains: z.array(z.string()),
+  metadataXml: z.string().nullish(),
+});
+
+export type SsoProvider = z.infer<typeof SsoProvider>;

package/src/workspace/user-invite.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { WorkspaceRoleSchema } from "./workspace-role";
+
+export const MAX_MEMBERS_COUNT = 100;
+
+export const UserInvite = z.object({
+  email: z
+    .string()
+    .email()
+    .trim()
+    .transform(value => value.toLowerCase()),
+  role: WorkspaceRoleSchema,
+});
+
+export const UserInvites = z.array(UserInvite).max(MAX_MEMBERS_COUNT);
+
+export type UserInvite = z.infer<typeof UserInvite>;
+export type UserInvites = z.infer<typeof UserInvites>;

package/src/workspace/workspace-context.ts

@@ -0,0 +1,10 @@
+import { ProductCodeSchema } from "../billing";
+import { z } from "zod";
+
+export const WorkspaceContext = z.object({
+  workspaceId: z.string(),
+  product: ProductCodeSchema,
+  publicDesignSystem: z.boolean().optional(),
+});
+
+export type WorkspaceContext = z.infer<typeof WorkspaceContext>;

package/src/workspace/workspace-create.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { UserInvites } from "./user-invite";
+import { SLUG_REGEX } from "../helpers";
+import { ProductCodeSchema } from "../billing";
+
+const WORKSPACE_NAME_MIN_LENGTH: number = 2;
+const WORKSPACE_NAME_MAX_LENGTH: number = 64;
+export const HANDLE_MIN_LENGTH = 2;
+export const HANDLE_MAX_LENGTH = 64;
+
+export const CreateWorkspaceInput = z.object({
+  name: z.string().min(WORKSPACE_NAME_MIN_LENGTH).max(WORKSPACE_NAME_MAX_LENGTH).trim(),
+  product: ProductCodeSchema,
+  priceId: z.string(),
+  billingEmail: z.string().email().optional(),
+  handle: z
+    .string()
+    .regex(SLUG_REGEX)
+    .min(HANDLE_MIN_LENGTH)
+    .max(HANDLE_MAX_LENGTH)
+    .refine(value => value?.length > 0)
+    .optional(),
+  invites: UserInvites.optional(),
+  promoCode: z.string().optional(),
+});
+
+export type CreateWorkspaceInput = z.infer<typeof CreateWorkspaceInput>;

package/src/workspace/workspace-invitations.ts

@@ -0,0 +1,14 @@
+import { WorkspaceRole } from "./workspace-role";
+import { z } from "zod";
+
+export const WorkspaceInvitation = z.object({
+  id: z.string(),
+  email: z.string().email(),
+  createdAt: z.date(),
+  resentAt: z.date().nullish(),
+  role: z.nativeEnum(WorkspaceRole),
+  workspaceId: z.string(),
+  invitedBy: z.string(),
+});
+
+export type WorkspaceInvitation = z.infer<typeof WorkspaceInvitation>;

package/src/workspace/workspace-membership.ts

@@ -0,0 +1,11 @@
+import { WorkspaceRole } from "./workspace-role";
+import { z } from "zod";
+
+export const WorkspaceMembership = z.object({
+  id: z.string(),
+  userId: z.string(),
+  workspaceId: z.string(),
+  workspaceRole: z.nativeEnum(WorkspaceRole),
+});
+
+export type WorkspaceMembership = z.infer<typeof WorkspaceMembership>;

package/src/workspace/workspace-role.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+
+export const WorkspaceRoleSchema = z.enum(["Owner", "Admin", "Creator", "Viewer", "Billing", "Guest"]);
+
+export type WorkspaceRole = z.infer<typeof WorkspaceRoleSchema>;
+export const WorkspaceRole = WorkspaceRoleSchema.enum;

package/src/workspace/workspace.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { Subscription } from "../billing";
+import { SsoProvider } from "./sso-provider";
+import { DesignSystem } from "../dsm";
+import { BillingDetails } from "../billing";
+
+export const WorkspaceIpWhitelistEntry = z.object({
+  isEnabled: z.boolean(),
+  name: z.string(),
+  range: z.string(),
+});
+
+export const WorkspaceIpSettings = z
+  .object({
+    isEnabledForCloud: z.boolean(),
+    isEnabledForDocs: z.boolean(),
+    entries: z.array(WorkspaceIpWhitelistEntry),
+  })
+  .nullish();
+
+export const WorkspaceProfile = z.object({
+  name: z.string(),
+  handle: z.string(),
+  color: z.string(),
+  avatar: z.string().optional(),
+  billingDetails: BillingDetails.optional(),
+});
+
+export const Workspace = z.object({
+  id: z.string(),
+  profile: WorkspaceProfile,
+  subscription: Subscription,
+  ipWhitelist: WorkspaceIpSettings,
+  sso: SsoProvider.nullish(),
+  npmRegistrySettings: z.unknown().optional(),
+  designSystems: z.array(DesignSystem).nullish(),
+});
+
+export const WorkspaceWithDesignSystems = z.object({
+  workspace: Workspace,
+  designSystems: z.array(DesignSystem),
+});
+
+export type WorkspaceIpWhitelistEntry = z.infer<typeof WorkspaceIpWhitelistEntry>;
+export type WorkspaceIpSettings = z.infer<typeof WorkspaceIpSettings>;
+export type WorkspaceProfile = z.infer<typeof WorkspaceProfile>;
+export type Workspace = z.infer<typeof Workspace>;
+export type WorkspaceWithDesignSystems = z.infer<typeof WorkspaceWithDesignSystems>;