@supernova-studio/model 0.0.4

package/index.ts

@@ -0,0 +1 @@
+export * from './src';

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@supernova-studio/model",
+  "version": "0.0.4",
+  "description": "Supernova Data Models",
+  "main": "index.ts",
+  "source": "index.ts",
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "typescript": "^5.0.4",
+    "zod": "^3.22.4",
+    "@sindresorhus/slugify": "1.1.2"
+  },
+  "devDependencies": {
+    "fs": "^0.0.1-security"
+  }
+}

package/src/auth/index.ts

@@ -0,0 +1 @@
+export * from "./plugin-oauth-request";

package/src/auth/plugin-oauth-request.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+export const PluginOAuthRequestSchema = z.object({
+  id: z.string(),
+  codeChallenge: z.string(),
+  readKey: z.string(),
+  writeKey: z.string(),
+  readKeyConsumed: z.boolean(),
+  writeKeyConsumed: z.boolean(),
+  oAuthCode: z.string().optional(),
+  createdAt: z.date(),
+});
+
+export type PluginOAuthRequest = z.infer<typeof PluginOAuthRequestSchema>;

package/src/billing/card.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+
+export const CardSchema = z.object({
+  cardId: z.string().nullish(),
+  last4: z.string().length(4).nullish(),
+  expiryMonth: z.string().nullish(),
+  expiryYear: z.string().nullish(),
+  brand: z.string().nullish(),
+  name: z.string().nullish(),
+});
+
+export type Card = z.infer<typeof CardSchema>;

package/src/billing/checkoutSession.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+
+export const PostStripeCheckoutBodyInputSchema = z.object({
+  priceId: z.string(),
+  successUrl: z.string().url(),
+  cancelUrl: z.string().url(),
+  quantity: z.number().int().min(1).optional(),
+});
+
+export const PostStripeCheckoutOutputSchema = z.object({
+  id: z.string(),
+  url: z.string().nullish(),
+});
+
+export type StripeCheckoutInput = z.infer<typeof PostStripeCheckoutBodyInputSchema>;
+export type StripeCheckoutOutput = z.infer<typeof PostStripeCheckoutOutputSchema>;

package/src/billing/customer.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+
+export const Customer = z.object({
+  id: z.string(),
+});
+
+export const Address = z.object({
+  street1: z.string().optional(),
+  street2: z.string().optional(),
+  city: z.string().optional(),
+  postal: z.string().optional(),
+  country: z.string().optional(),
+  state: z.string().optional(),
+});
+
+export const BillingDetails = z.object({
+  address: Address.optional(),
+  email: z.string().optional(),
+  companyName: z.string().optional(),
+  companyId: z.string().optional(),
+  notes: z.string().optional(),
+  vat: z.string().optional(),
+  poNumber: z.string().optional(),
+});
+
+export type Customer = z.infer<typeof Customer>;
+export type Address = z.infer<typeof Address>;
+export type BillingDetails = z.infer<typeof BillingDetails>;

package/src/billing/features.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+
+const featureLimitedSchema = z.object({
+  max: z.number(),
+  errorMessage: z.string(),
+  errorReason: z.string(),
+});
+
+const featureToggleSchema = z.object({
+  enabled: z.boolean(),
+  errorMessage: z.string(),
+  errorReason: z.string(),
+});
+
+const featureWithImportJobsSchema = featureLimitedSchema.extend({
+  noImportJobsErrorMessage: z.string(),
+  noImportJobsErrorReason: z.string(),
+});
+
+export const FeaturesSummary = z.object({
+  designSystems: featureLimitedSchema,
+  designSystemSources: featureWithImportJobsSchema,
+  designSystemVersions: featureLimitedSchema,
+  themes: featureLimitedSchema,
+  brands: featureLimitedSchema,
+  codegenSchedules: featureLimitedSchema,
+  publicDocumentation: featureToggleSchema,
+  customDocumentationUrl: featureToggleSchema,
+  customDocumentationViewButton: featureToggleSchema,
+  designSystemSourceAutoImport: featureToggleSchema,
+  designSystemSlug: featureToggleSchema,
+  ipWhitelisting: featureToggleSchema,
+  npmRegistry: featureToggleSchema,
+  sso: featureToggleSchema,
+  workspacePaidSeats: featureLimitedSchema,
+  workspaceViewers: featureLimitedSchema,
+  customDocumentationExporter: featureToggleSchema,
+});
+
+export type FeatureLimitedDetails = z.infer<typeof featureLimitedSchema>;
+export type FeatureToggleDetails = z.infer<typeof featureToggleSchema>;
+export type FeatureWithImportJobsDetails = z.infer<typeof featureWithImportJobsSchema>;
+export type FeaturesSummary = z.infer<typeof FeaturesSummary>;

package/src/billing/index.ts

@@ -0,0 +1,9 @@
+export * from "./card";
+export * from "./checkoutSession";
+export * from "./customer";
+export * from "./features";
+export * from "./invoice";
+export * from "./portalSession";
+export * from "./price";
+export * from "./product";
+export * from "./subscription";

package/src/billing/invoice.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { CardSchema } from "./card";
+
+export const InvoiceSchema = z.object({
+  id: z.string(),
+  number: z.string(),
+  amount_due: z.number(),
+  date: z.date(),
+  hostedUrl: z.string().url(),
+  card: CardSchema.nullish(),
+});
+
+export const PeriodSchema = z.object({
+  start: z.date(),
+  end: z.date(),
+});
+
+export const InvoiceLineSchema = z.object({
+  amount: z.number(),
+  period: PeriodSchema,
+  proration: z.boolean(),
+  description: z.string(),
+  type: z.string(),
+});
+
+export const InvoiceCouponSchema = z.object({
+  amount_off: z.number(),
+  percent_off: z.number(),
+  name: z.string(),
+});
+
+export type Invoice = z.infer<typeof InvoiceSchema>;
+export type InvoiceLine = z.infer<typeof InvoiceLineSchema>;
+export type InvoiceCoupon = z.infer<typeof InvoiceCouponSchema>;

package/src/billing/portalSession.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+
+export const PostStripePortalUpdateSessionBodyInputSchema = z.object({
+  priceId: z.string(),
+  numberOfSeats: z.number().int(),
+});
+export const PostStripePortalSessionBodyInputSchema = z.object({
+  returnUrl: z.string().url(),
+  update: PostStripePortalUpdateSessionBodyInputSchema.optional(),
+  cancel: z.boolean().optional(),
+});
+
+export const PostStripePortalSessionOutputSchema = z.object({
+  id: z.string(),
+  url: z.string().nullish(),
+});
+
+export type StripePortalSessionInput = z.infer<typeof PostStripePortalSessionBodyInputSchema>;
+export type StripePortalSessionOutput = z.infer<typeof PostStripePortalSessionOutputSchema>;

package/src/billing/price.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+export const BillingIntervalSchema = z.enum(["daily", "monthly", "weekly", "yearly"]);
+
+export const PriceSchema = z.object({
+  stripePriceId: z.string(),
+  stripeProductId: z.string(),
+  stripeProductName: z.string().optional(),
+  stripeProductDescription: z.string().optional(),
+  active: z.boolean(),
+  amount: z.number(),
+  interval: BillingIntervalSchema,
+  isPricePerCreator: z.boolean().optional(),
+  isTrial: z.boolean().optional(),
+  isHidden: z.boolean().optional(),
+  minimumSeats: z.number().optional(),
+  legacyVersion: z.string().optional(),
+  featuresSet: z.string().optional(),
+  stripeProductFeatures: z.array(z.string()).optional(),
+  stripeProductAdditionalFeatures: z.array(z.string()).optional(),
+});
+
+export type BillingInterval = z.infer<typeof BillingIntervalSchema>;
+export type Price = z.infer<typeof PriceSchema>;

package/src/billing/product.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+export const ProductCodeSchema = z.enum(["free", "team", "team_test", "company", "enterprise"]);
+export type ProductCode = z.infer<typeof ProductCodeSchema>;
+export const ProductCode = ProductCodeSchema.enum;

package/src/billing/subscription.ts

@@ -0,0 +1,65 @@
+import { CardSchema } from "./card";
+import { ProductCode, ProductCodeSchema } from "./product";
+import { FeaturesSummary } from "./features";
+import { BillingIntervalSchema } from "./price";
+import { z } from "zod";
+export const StripeSubscriptionStatusSchema = z.enum([
+  "trialing",
+  "active",
+  "past_due",
+  "canceled",
+  "unpaid",
+  "incomplete_expired",
+  "incomplete",
+  "unknown",
+]);
+
+export const InternalStatusSchema = z.enum(["active", "suspended", "gracePeriod", "cancelled", "downgraded_to_free"]);
+
+export const BillingTypeSchema = z.enum(["Auto", "Invoice"]);
+
+export type StripeSubscriptionStatus = z.infer<typeof StripeSubscriptionStatusSchema>;
+export type InternalStatus = z.infer<typeof InternalStatusSchema>;
+export type BillingType = z.infer<typeof BillingTypeSchema>;
+
+export const StripeSubscriptionStatus = StripeSubscriptionStatusSchema.enum;
+export const InternalStatus = InternalStatusSchema.enum;
+export const BillingType = BillingTypeSchema.enum;
+
+export const Subscription = z.object({
+  stripeSubscriptionId: z.string().nullish(),
+  stripeCustomerId: z.string().nullish(),
+
+  status: InternalStatusSchema.optional(),
+  subscriptionStatus: StripeSubscriptionStatusSchema.optional(), // the stripe API official status
+  internalStatus: InternalStatusSchema.optional(), // TODO: delete when create/get workspace will stop using it in the former API
+
+  product: ProductCodeSchema,
+  featuresSummary: FeaturesSummary.optional(),
+  stripeProductDescription: z.string().optional(),
+  stripeProductFeatures: z.array(z.string()).optional(),
+  stripeProductAdditionalFeatures: z.array(z.string()).optional(),
+  stripeSubscriptionMainItemId: z.string().optional(),
+  planPriceId: z.string(),
+  planInterval: BillingIntervalSchema,
+  isPricePerCreator: z.boolean().optional(),
+  legacyVersion: z.string().optional(),
+
+  seats: z.number(),
+  seatLimit: z.number(),
+
+  currentPeriodStart: z.string().optional(),
+  currentPeriodEnd: z.string().optional(),
+  subscriptionStatusUpdatedAt: z.string().optional(),
+  cancelAt: z.string().nullish(),
+
+  card: CardSchema.optional(),
+
+  // New
+  amount: z.number().nullish(),
+  isTrial: z.boolean().optional(),
+  billingType: BillingTypeSchema.optional(),
+  daysUntilDue: z.number().optional(),
+});
+
+export type Subscription = z.infer<typeof Subscription>;

package/src/codegen/export-jobs.ts

@@ -0,0 +1,26 @@
+import { PublishedDocEnvironment } from "../dsm";
+import { z } from "zod";
+export const ExportJobStatus = z.union([
+  z.literal("Success"),
+  z.literal("InProgress"),
+  z.literal("Timeout"),
+  z.literal("Failed"),
+]);
+
+export type ExportJobStatus = z.infer<typeof ExportJobStatus>;
+
+export const ExportJob = z.object({
+  id: z.string(),
+  workspaceId: z.string(),
+  designSystemId: z.string(),
+  designSystemVersionId: z.string(),
+  status: ExportJobStatus,
+  docsUrl: z.string().nullish(),
+  scheduleId: z.string().nullish(),
+  exporterId: z.string().nullish(),
+  createdAt: z.date(),
+  environment: PublishedDocEnvironment,
+  finishedAt: z.date().nullish(),
+});
+
+export type ExportJob = z.infer<typeof ExportJob>;

package/src/codegen/exporter-workspace-membership-role.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+
+export const ExporterWorkspaceMembershipRole = z.enum(["Owner", "OwnerArchived", "User"]);
+export type ExporterWorkspaceMembershipRole = z.infer<typeof ExporterWorkspaceMembershipRole>;

package/src/codegen/exporter-workspace-membership.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { ExporterWorkspaceMembershipRole } from "./exporter-workspace-membership-role";
+import { DbCreateInputOmit } from "../helpers";
+
+export const ExporterWorkspaceMembership = z.object({
+  id: z.string(),
+  workspaceId: z.string(),
+  exporterId: z.string(),
+  role: ExporterWorkspaceMembershipRole,
+});
+
+export type ExporterWorkspaceMembership = z.infer<typeof ExporterWorkspaceMembership>;
+
+export type CreateExporterMembership = DbCreateInputOmit<ExporterWorkspaceMembership>;

package/src/codegen/exporter.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { GitProvider } from "./git-providers";
+import { PulsarContributionBlock, PulsarContributionConfigurationProperty, PulsarContributionVariant } from "./pulsar";
+import { nullishToOptional } from "../helpers";
+
+export const ExporterType = z.enum(["code", "documentation"]);
+export const ExporterSource = z.enum(["git", "upload"]);
+export const ExporterTag = z.string().regex(/^[0-9a-zA-Z]+(\s[0-9a-zA-Z]+)*$/);
+
+export const ExporterDetails = z.object({
+  packageId: z.string().max(255),
+  version: z.string(),
+  description: z.string(),
+  author: nullishToOptional(z.string()),
+  organization: nullishToOptional(z.string()),
+  homepage: nullishToOptional(z.string()),
+  readme: nullishToOptional(z.string()),
+  tags: z.array(ExporterTag).default([]),
+
+  routingVersion: nullishToOptional(z.string()),
+
+  iconURL: nullishToOptional(z.string()),
+  configurationProperties: z.array(PulsarContributionConfigurationProperty).default([]),
+  customBlocks: z.array(PulsarContributionBlock).default([]),
+  blockVariants: z.record(z.string(), z.array(PulsarContributionVariant)).default({}),
+
+  usesBrands: z.boolean().default(false),
+  usesThemes: z.boolean().default(false),
+
+  source: ExporterSource,
+
+  gitProvider: nullishToOptional(GitProvider),
+  gitUrl: nullishToOptional(z.string()),
+  gitBranch: nullishToOptional(z.string()),
+  gitDirectory: nullishToOptional(z.string()),
+});
+
+export const Exporter = z.object({
+  id: z.string(),
+  createdAt: z.coerce.date(),
+  name: z.string(),
+  isPrivate: z.boolean(),
+  details: ExporterDetails,
+  exporterType: ExporterType.default("code"),
+  storagePath: z.string().default(""),
+});
+
+export type ExporterType = z.infer<typeof ExporterType>;
+export type ExporterSource = z.infer<typeof ExporterSource>;
+export type ExporterTag = z.infer<typeof ExporterTag>;
+export type ExporterDetails = z.infer<typeof ExporterDetails>;
+export type Exporter = z.infer<typeof Exporter>;

package/src/codegen/git-providers.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+
+export enum GitProviderNames {
+  Azure = "azure",
+  Github = "github",
+  Gitlab = "gitlab",
+  Bitbucket = "bitbucket",
+}
+
+export const GitProvider = z.nativeEnum(GitProviderNames);
+export type GitProvider = z.infer<typeof GitProvider>;

package/src/codegen/index.ts

@@ -0,0 +1,6 @@
+export * from "./export-jobs";
+export * from "./exporter-workspace-membership-role";
+export * from "./exporter-workspace-membership";
+export * from "./exporter";
+export * from "./git-providers";
+export * from "./pulsar";

package/src/codegen/pulsar.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+
+export const PulsarContributionVariant = z.object({
+  key: z.string(),
+  name: z.string(),
+  isDefault: z.boolean().optional(),
+  description: z.string().optional(),
+  thumbnailURL: z.string().optional(),
+});
+export type PulsarContributionVariant = z.infer<typeof PulsarContributionVariant>;
+
+export const PulsarPropertyType = z.enum([
+  "string",
+  "number",
+  "boolean",
+  "image",
+  "enum",
+  "color",
+  "typography",
+  "component",
+  "componentProperties",
+  "tokenProperties",
+  "tokenType",
+]);
+export type PulsarPropertyType = z.infer<typeof PulsarPropertyType>;
+
+// export type PulsarPropertyValueType =
+//   | string
+//   | number
+//   | boolean
+//   | PulsarPropertyImageValue
+//   | ColorTokenData // TODO: Should we do smth here? Update Pulsar to get value?!
+//   | TypographyTokenData;
+
+export const BasePulsarProperty = z.object({
+  label: z.string(),
+  key: z.string(),
+  description: z.string().optional(),
+  type: PulsarPropertyType,
+  values: z.array(z.string()).optional(),
+  default: z.union([z.string(), z.boolean(), z.number()]).nullish(), // PulsarPropertyValueType //is optional?
+  inputType: z.enum(["code", "plain"]).optional(), //is optional?
+  isMultiline: z.boolean().optional(),
+});
+export type BasePulsarProperty = z.infer<typeof BasePulsarProperty>;
+
+export const PulsarContributionBlock = z.object({
+  title: z.string(),
+  key: z.string(),
+  category: z.string(),
+  description: z.string().optional(),
+  iconURL: z.string(),
+  mode: z.enum(["array", "block"]),
+  properties: z.array(BasePulsarProperty),
+});
+export type PulsarContributionBlock = z.infer<typeof PulsarContributionBlock>;
+
+export const PulsarContributionConfigurationProperty = BasePulsarProperty.extend({ category: z.string() });
+export type PulsarContributionConfigurationProperty = z.infer<typeof PulsarContributionConfigurationProperty>;

package/src/common/entity.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const Entity = z.object({
+  id: z.string(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export type Entity = z.infer<typeof Entity>;

package/src/common/index.ts

@@ -0,0 +1,2 @@
+export * from "./entity";
+export * from "./object-meta";

package/src/common/object-meta.ts

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

package/src/custom-domains/custom-domains.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+export type CustomDomainState =
+  | "Initial"
+  | "DomainSetupInProgress"
+  | "DomainSetupFailed"
+  | "DomainSetupSuccess"
+  | "SSLSetupInProgress"
+  | "SSLSetupFailed"
+  | "SSLSetupSuccess";
+
+export const CustomDomain = z.object({
+  id: z.string(),
+  designSystemId: z.string(),
+  state: z.string(),
+
+  supernovaDomain: z.string(),
+  customerDomain: z.string().nullish(),
+
+  error: z.string().nullish(),
+  errorCode: z.string().nullish(),
+});
+
+export type CustomDomain = z.infer<typeof CustomDomain>;

package/src/custom-domains/index.ts

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

package/src/docs-server/index.ts

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

package/src/docs-server/session.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { User } from "../users";
+
+export const NpmProxyToken = z.object({
+  access: z.string(),
+  expiresAt: z.number(),
+});
+
+export type NpmProxyToken = z.infer<typeof NpmProxyToken>;
+
+export const SessionData = z.object({
+  returnToUrl: z.string().optional(),
+  npmProxyToken: NpmProxyToken.optional(),
+});
+
+export type SessionData = z.infer<typeof SessionData>;
+
+export const Session = z.object({
+  id: z.string(),
+  expiresAt: z.date(),
+  userId: z.string().nullable(),
+  data: SessionData,
+});
+
+export type Session = z.infer<typeof Session>;
+
+export const AuthTokens = z.object({
+  access: z.string(),
+  refresh: z.string(),
+});
+
+export type AuthTokens = z.infer<typeof AuthTokens>;
+
+export const UserSession = z.object({
+  session: Session,
+  user: User.nullable(),
+});
+
+export type UserSession = z.infer<typeof UserSession>;

package/src/dsm/assets/asset-reference.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { DbCreateInputOmit } from "../../helpers";
+
+export const AssetReference = z.object({
+  id: z.string(),
+  designSystemVersionId: z.string(),
+  assetId: z.string(),
+  persistentId: z.string(),
+});
+
+export type AssetReference = z.infer<typeof AssetReference>;
+
+export type CreateAssetReference = DbCreateInputOmit<AssetReference>;
+
+export type AssetReferenceDiff = {
+  toCreate: CreateAssetReference[];
+  toDelete: string[];
+};

package/src/dsm/assets/asset-value.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+export const AssetValue = z.object({});

package/src/dsm/assets/asset.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { OmitStrict } from "../../helpers";
+
+export const AssetType = z.enum(["Image", "Font"]);
+export const AssetScope = z.enum(["DocumentationFrame", "ComponentThumbnail", "DesignSystem", "Documentation"]);
+
+export const AssetFontProperties = z.object({
+  family: z.string(),
+  subfamily: z.string(),
+});
+
+export const AssetProperties = z.object({
+  fontProperties: z.array(AssetFontProperties),
+});
+
+export const AssetOrigin = z.object({
+  originKey: z.string(),
+});
+
+export const Asset = z.object({
+  id: z.string(),
+  designSystemId: z.string().nullish(),
+  type: AssetType,
+  originalFileName: z.string().nullish(),
+  filePath: z.string(),
+  scope: AssetScope,
+  properties: AssetProperties.nullish(),
+  origin: AssetOrigin.nullish(),
+});
+
+export type AssetType = z.infer<typeof AssetType>;
+export type AssetScope = z.infer<typeof AssetScope>;
+export type AssetFontProperties = z.infer<typeof AssetFontProperties>;
+export type AssetProperties = z.infer<typeof AssetProperties>;
+export type AssetOrigin = z.infer<typeof AssetOrigin>;
+export type Asset = z.infer<typeof Asset>;
+
+export type ImportedAsset = OmitStrict<Asset, "origin"> & {
+  origin: AssetOrigin;
+};
+
+export type ResolvedAsset = OmitStrict<Asset, "filePath"> & {
+  url: string;
+};
+
+export function isImportedAsset(asset: Asset): asset is ImportedAsset {
+  return !!asset.origin;
+}

package/src/dsm/assets/index.ts

@@ -0,0 +1,3 @@
+export * from "./asset-reference";
+export * from "./asset-value";
+export * from "./asset";