@supernova-studio/model 1.0.0 → 1.0.1

package/src/users/user.ts

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

package/src/utils/common.ts

@@ -1,172 +0,0 @@
-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 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] };
-
-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 tryParseUrl(url: string): URL | null {
-  try {
-    return parseUrl(url);
-  } catch (e) {
-    console.error(`Error parsing URL ${url}`);
-    console.error(e);
-    return null;
-  }
-}
-
-export function parseUrl(url: string): URL {
-  return new URL(url.startsWith("https://") || url.startsWith("http://") ? url : `https://${url}`);
-}
-
-export function mapByUnique<V, K>(items: Iterable<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>,
-  onTimeout?: () => Error
-): Promise<T> {
-  let timeoutHandle: NodeJS.Timeout | undefined;
-  const timeoutPromise = new Promise<never>((_, reject) => {
-    timeoutHandle = setTimeout(() => reject(onTimeout?.() ?? 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 function uniqueBy<K, V>(items: V[], prop: (v: V) => K): V[] {
-  return Array.from(mapByUnique(items, prop).values());
-}
-
-export function areShallowObjectsEqual<T extends object>(lhs: T | undefined, rhs: T | undefined) {
-  if ((lhs === undefined) !== (rhs === undefined)) return false;
-  if (lhs === undefined || rhs === undefined) return true;
-
-  if ((lhs === null) !== (rhs === null)) return false;
-  if (lhs === null || rhs === null) return true;
-
-  for (const key in lhs) {
-    if (!(key in rhs) || lhs[key] !== rhs[key]) {
-      return false;
-    }
-  }
-
-  for (const key in rhs) {
-    if (!(key in lhs)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function isNotNullish<T>(value: T | null | undefined): value is T {
-  return !isNullish(value);
-}
-
-export function isNullish<T>(value: T | null | undefined): value is null | undefined {
-  return value === null || value === undefined;
-}
-
-export function chunkedArray<V>(array: V[], chunkSize: number): V[][] {
-  const result: V[][] = [];
-  for (let i = 0; i < array.length; i += chunkSize) {
-    result.push(array.slice(i, i + chunkSize));
-  }
-  return result;
-}
-
-export type Pagination = {
-  skip?: number;
-  take?: number;
-};

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

@@ -1,31 +0,0 @@
-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/errors.ts

@@ -1,120 +0,0 @@
-export type SupernovaExceptionType =
-  | "AccessDenied"
-  | "ResourceNotFound"
-  | "WrongFormat"
-  | "TooMuchWork"
-  | "Timeout"
-  | "Conflict"
-  | "NotImplemented"
-  | "BadRequest"
-  | "WrongActionOrder"
-  | "InvalidOperation"
-  | "UnexpectedError"
-  | "IPRestricted"
-  | "PlanRestricted"
-  | "MissingWorkspacePermission"
-  | "MissingExporterPermission"
-  | "MissingIntegration"
-  | "MissingIntegrationAccess"
-  | "NoAccess"
-  | "MissingCredentials"
-  | "ValidationError"
-  | "ThirdPartyError";
-
-export class SupernovaException extends Error {
-  static wrongFormat(message?: string): SupernovaException {
-    return new SupernovaException("WrongFormat", message);
-  }
-
-  static validationError(message?: string): SupernovaException {
-    return new SupernovaException("ValidationError", message);
-  }
-
-  static accessDenied(message?: string): SupernovaException {
-    return new SupernovaException("AccessDenied", message);
-  }
-
-  static tooMuchWork(message?: string): SupernovaException {
-    return new SupernovaException("TooMuchWork", 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("MissingIntegration", message);
-  }
-
-  static missingIntegrationAccess(message?: string): SupernovaException {
-    return new SupernovaException("MissingIntegrationAccess", message);
-  }
-
-  static noAccess(message?: string): SupernovaException {
-    return new SupernovaException("NoAccess", message);
-  }
-
-  static missingCredentials(message?: string): SupernovaException {
-    return new SupernovaException("MissingCredentials", message);
-  }
-
-  static thirdPartyError(message?: string): SupernovaException {
-    return new SupernovaException("ThirdPartyError", 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,6 +0,0 @@
-export * from "./common";
-export * from "./content-loader-instruction";
-export * from "./errors";
-export * from "./naming";
-export * from "./slugify";
-export * from "./validation";

package/src/utils/naming.ts

@@ -1,73 +0,0 @@
-// this has been ported from the Dart cloud app
-export function getCodenameFromText(name: string): string {
-  // Turn all characters with diacritics into their simple form (ě -> e, ö -> o, etc.)
-  let codeName = removeDiacritics(name);
-
-  // Remove all invalid characters
-  codeName = codeName.replace(/[^a-zA-Z0-9$_ ]+/g, "");
-  // Remove all starting numbers
-  codeName = codeName.replace(/^[0-9 ]+/g, "");
-  // Change to CamelCase
-  codeName = toCamelCase(codeName.toLowerCase());
-  // Remove all spaces
-  codeName = codeName.replace(/ /g, "");
-
-  if (codeName) {
-    // Lowercase the first letter
-    codeName = codeName.charAt(0).toLowerCase() + codeName.slice(1);
-  }
-
-  return codeName;
-}
-
-function toCamelCase(str: string): string {
-  return str.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, function (match, index) {
-    if (+match === 0) return ""; // or if (/\s+/.test(match)) for white spaces
-    return index === 0 ? match.toLowerCase() : match.toUpperCase();
-  });
-}
-
-function removeDiacritics(str: string): string {
-  const diacriticsMap = [
-    {
-      base: "A",
-      letters:
-        /[\u0041\u24B6\uFF21\u00C0\u00C1\u00C2\u1EA6\u1EA4\u1EAA\u1EA8\u00C3\u0100\u0102\u1EB0\u1EAE\u1EB4\u1EB2\u0226\u01E0\u00C4\u01DE\u1EA2\u00C5\u01FA\u01CD\u0200\u0202\u1EA0\u1EAC\u1EB6\u1E00\u0104\u023A\u2C6F]/g,
-    },
-    { base: "AA", letters: /[\uA732]/g },
-    { base: "AE", letters: /[\u00C6\u01FC\u01E2]/g },
-    { base: "AO", letters: /[\uA734]/g },
-    { base: "AU", letters: /[\uA736]/g },
-    { base: "AV", letters: /[\uA738\uA73A]/g },
-    { base: "AY", letters: /[\uA73C]/g },
-    {
-      base: "B",
-      letters: /[\u0042\u24B7\uFF22\u1E02\u1E04\u1E06\u0243\u0182\u0181]/g,
-    },
-    {
-      base: "C",
-      letters: /[\u0043\u24B8\uFF23\u0106\u0108\u010A\u010C\u00C7\u1E08\u0187\u023B\uA73E]/g,
-    },
-    /* ... */
-    {
-      base: "Z",
-      letters: /[\u005A\u24CF\uFF3A\u0179\u1E90\u017B\u017D\u1E92\u1E94\u01B5\u0224\u2C7F\u2C6B\uA762]/g,
-    },
-    {
-      base: "a",
-      letters:
-        /[\u0061\u24D0\uFF41\u1E9A\u00E0\u00E1\u00E2\u1EA7\u1EA5\u1EAB\u1EA9\u00E3\u0101\u0103\u1EB1\u1EAF\u1EB5\u1EB3\u0227\u01E1\u00E4\u01DF\u1EA3\u00E5\u01FB\u01CE\u0201\u0203\u1EA1\u1EAD\u1EB7\u1E01\u0105\u2C65\u0250]/g,
-    },
-    /* ... */
-    {
-      base: "z",
-      letters: /[\u007A\u24E9\uFF5A\u017A\u1E91\u017C\u017E\u1E93\u1E95\u01B6\u0225\u0240\u2C6C\uA763]/g,
-    },
-  ];
-
-  diacriticsMap.forEach(diacritic => {
-    str = str.replace(diacritic.letters, diacritic.base);
-  });
-
-  return str;
-}