@supernova-studio/client 0.54.19 → 0.54.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supernova-studio/client",
-  "version": "0.54.19",
+  "version": "0.54.21",
   "description": "Supernova Data Models",
   "source": "src/index.ts",
   "main": "dist/index.js",

package/src/api/client.ts

@@ -0,0 +1,26 @@
+import { WorkspacesEndpoint } from "./endpoints";
+import { DesignSystemsEndpoint } from "./endpoints/design-systems";
+import { UsersEndpoint } from "./endpoints/users";
+import { RequestExecutor } from "./transport/request-executor";
+
+type SupernovaApiClientConfig = {
+  host: string;
+  accessToken: string;
+};
+
+export class SupernovaApiClient {
+  readonly users: UsersEndpoint;
+  readonly workspaces: WorkspacesEndpoint;
+  readonly designSystems: DesignSystemsEndpoint;
+
+  constructor(config: SupernovaApiClientConfig) {
+    const requestExecutor = new RequestExecutor({
+      host: config.host,
+      accessToken: config.accessToken,
+    });
+
+    this.users = new UsersEndpoint(requestExecutor);
+    this.workspaces = new WorkspacesEndpoint(requestExecutor);
+    this.designSystems = new DesignSystemsEndpoint(requestExecutor);
+  }
+}

package/src/api/dto/bff/app-bootstrap-data.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { DTOBrand, DTODesignSystem, DTODesignSystemVersion } from "../design-systems";
+import { DTOUserWorkspaceMembership } from "../workspaces";
+
+export const DTOAppBootstrapDataQuery = z.object({
+  preferredWorkspaceId: z.string().optional(),
+  preferredDesignSystemId: z.string().optional(),
+  preferredVersionId: z.string().optional(),
+  preferredBrandId: z.string().optional(),
+});
+
+export const DTOAppBootstrapDataResponse = z.object({
+  workspaceMembership: DTOUserWorkspaceMembership.optional(),
+  designSystem: DTODesignSystem.optional(),
+  version: DTODesignSystemVersion.optional(),
+  brand: DTOBrand.optional(),
+});
+
+export type DTOAppBootstrapDataQuery = z.infer<typeof DTOAppBootstrapDataQuery>;
+export type DTOAppBootstrapDataResponse = z.infer<typeof DTOAppBootstrapDataResponse>;

package/src/api/dto/bff/index.ts

@@ -0,0 +1 @@
+export * from "./app-bootstrap-data";

package/src/api/dto/design-systems/members.ts

@@ -25,8 +25,8 @@ export type DTODesignSystemMembersUpdateResponse = z.infer<typeof DTODesignSyste
 //
 
 export const DTODesignSystemMembersUpdatePayload = z.object({
-  inviteUserIds: z.string().array(),
-  removeUserIds: z.string().array(),
+  inviteUserIds: z.string().array().optional(),
+  removeUserIds: z.string().array().optional(),
 });
 
 export type DTODesignSystemMembersUpdatePayload = z.infer<typeof DTODesignSystemMembersUpdatePayload>;

package/src/api/dto/index.ts

@@ -1,4 +1,5 @@
 export * from "./aux";
+export * from "./bff";
 export * from "./design-systems";
 export * from "./documentation";
 export * from "./elements";

package/src/api/dto/users/user.ts

@@ -18,5 +18,10 @@ export const DTOUser = z.object({
   profile: DTOUserProfile,
 });
 
+export const DTOUserGetResponse = z.object({
+  user: DTOUser,
+});
+
 export type DTOUserProfile = z.infer<typeof DTOUserProfile>;
 export type DTOUser = z.infer<typeof DTOUser>;
+export type DTOUserGetResponse = z.infer<typeof DTOUserGetResponse>;

package/src/api/dto/workspaces/index.ts

@@ -1,5 +1,6 @@
 export * from "./git";
 export * from "./integrations";
+export * from "./invitations";
 export * from "./membership";
 export * from "./npm-registry";
 export * from "./workspace";

package/src/api/dto/workspaces/invitations.ts

@@ -0,0 +1,15 @@
+import { WorkspaceRoleSchema } from "@supernova-studio/model";
+import { z } from "zod";
+
+export const DTOWorkspaceInvitationInput = z.object({
+  email: z.string().email(),
+  role: WorkspaceRoleSchema,
+});
+
+export const DTOWorkspaceInvitationsListInput = z.object({
+  invites: DTOWorkspaceInvitationInput.array().max(100),
+  designSystemId: z.string().optional(),
+});
+
+export type DTOWorkspaceInvitationInput = z.infer<typeof DTOWorkspaceInvitationInput>;
+export type DTOWorkspaceInvitationsListInput = z.infer<typeof DTOWorkspaceInvitationsListInput>;

package/src/api/dto/workspaces/workspace.ts

@@ -14,3 +14,18 @@ export const DTOWorkspace = z.object({
 });
 
 export type DTOWorkspace = z.infer<typeof DTOWorkspace>;
+
+//
+// Write
+//
+
+export const DTOWorkspaceCreateInput = z.object({
+  name: z.string(),
+});
+
+export const DTOWorkspaceCreateResponse = z.object({
+  workspace: DTOWorkspace,
+});
+
+export type DTOWorkspaceCreateInput = z.infer<typeof DTOWorkspaceCreateInput>;
+export type DTOWorkspaceCreateResponse = z.infer<typeof DTOWorkspaceCreateResponse>;

package/src/api/endpoints/design-systems.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import {
+  DTODesignSystemCreateInput,
+  DTODesignSystemCreateResponse,
+  DTODesignSystemMembersUpdatePayload,
+  DTODesignSystemMembersUpdateResponse,
+  DTODesignSystemsListResponse,
+} from "../dto";
+import { RequestExecutor } from "../transport/request-executor";
+
+export class DesignSystemsEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  create(body: DTODesignSystemCreateInput) {
+    return this.requestExecutor.json("/design-systems", DTODesignSystemCreateResponse, { method: "POST", body });
+  }
+
+  list(wsId: string) {
+    return this.requestExecutor.json(`/workspaces/${wsId}/design-systems`, DTODesignSystemsListResponse);
+  }
+
+  get(dsId: string) {
+    return this.requestExecutor.json(`/design-systems/${dsId}`, z.any());
+  }
+
+  delete(dsId: string) {
+    return this.requestExecutor.json(`/design-systems/${dsId}`, z.any(), { method: "DELETE" });
+  }
+
+  editMembers(dsId: string, body: DTODesignSystemMembersUpdatePayload) {
+    return this.requestExecutor.json(`/design-systems/${dsId}/members`, DTODesignSystemMembersUpdateResponse, {
+      method: "POST",
+      body,
+    });
+  }
+}

package/src/api/endpoints/index.ts

@@ -0,0 +1,3 @@
+export * from "./design-systems";
+export * from "./users";
+export * from "./workspaces";

package/src/api/endpoints/users.ts

@@ -0,0 +1,10 @@
+import { DTOUserGetResponse } from "../dto";
+import { RequestExecutor } from "../transport/request-executor";
+
+export class UsersEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  getMe() {
+    return this.requestExecutor.json("/users/me", DTOUserGetResponse);
+  }
+}

package/src/api/endpoints/workspaces.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { DTOWorkspaceCreateInput, DTOWorkspaceCreateResponse, DTOWorkspaceInvitationsListInput } from "../dto";
+import { RequestExecutor } from "../transport/request-executor";
+
+export class WorkspacesEndpoint {
+  constructor(private readonly requestExecutor: RequestExecutor) {}
+
+  create(body: DTOWorkspaceCreateInput) {
+    return this.requestExecutor.json("/workspaces", DTOWorkspaceCreateResponse, {
+      method: "POST",
+      body: {
+        ...body,
+        product: "free",
+        priceId: "yearly",
+      },
+    });
+  }
+
+  delete(workspaceId: string) {
+    return this.requestExecutor.json(`/workspaces/${workspaceId}`, z.any(), { method: "DELETE" });
+  }
+
+  invite(workspaceId: string, body: DTOWorkspaceInvitationsListInput) {
+    return this.requestExecutor.json(`/workspaces/${workspaceId}/members`, z.any(), { method: "POST", body });
+  }
+}

package/src/api/index.ts

@@ -1,3 +1,6 @@
 export * from "./conversion";
 export * from "./dto";
+export * from "./endpoints";
 export * from "./payloads";
+export * from "./transport";
+export * from "./client";

package/src/api/transport/index.ts

@@ -0,0 +1,2 @@
+export * from "./request-executor-error";
+export * from "./request-executor";

package/src/api/transport/request-executor-error.ts

@@ -0,0 +1,18 @@
+export type RequestExecutorErrorType = "ServerError" | "ResponseParsingError";
+
+export class RequestExecutorError extends Error {
+  static serverError(endpoint: string, status: number, bodyText: string) {
+    return new RequestExecutorError("ServerError", `Endpoint ${endpoint} returned ${status}\n${bodyText}`);
+  }
+
+  static responseParsingError(endpoint: string, cause: Error) {
+    return new RequestExecutorError("ResponseParsingError", `Endpoint ${endpoint} returned incompatible JSON`, cause);
+  }
+
+  readonly type: RequestExecutorErrorType;
+
+  private constructor(type: RequestExecutorErrorType, message: string, cause?: unknown) {
+    super(`${type}: ${message}`, { cause });
+    this.type = type;
+  }
+}

package/src/api/transport/request-executor.ts

@@ -0,0 +1,72 @@
+import fetch, { RequestInit } from "node-fetch";
+import { z, ZodSchema, ZodTypeDef } from "zod";
+import { RequestExecutorError } from "./request-executor-error";
+
+export type RequestExecutorConfig = {
+  host: string;
+  accessToken?: string;
+};
+
+export type RequestExecutorJSONRequest = Omit<RequestInit, "body"> & {
+  body?: object;
+};
+
+const ResponseWrapper = z.object({
+  result: z.record(z.any()),
+});
+
+export class RequestExecutor {
+  private readonly testServerConfig: RequestExecutorConfig;
+
+  constructor(testServerConfig: RequestExecutorConfig) {
+    this.testServerConfig = testServerConfig;
+  }
+
+  async json<O, I>(path: string, schema: ZodSchema<O, ZodTypeDef, I>, requestInit: RequestExecutorJSONRequest = {}) {
+    // Headers
+    const defaultHeaders: Record<string, string> = {
+      Accept: "application/json",
+    };
+
+    if (requestInit.body) defaultHeaders["Content-Type"] = "application/json";
+    if (this.testServerConfig.accessToken) {
+      defaultHeaders["Authorization"] = `Bearer ${this.testServerConfig.accessToken}`;
+    }
+
+    // Body
+    let body: string | undefined;
+    if (requestInit.body && typeof requestInit.body === "object") body = JSON.stringify(requestInit.body);
+
+    const response = await fetch(this.fullUrl(path), {
+      ...requestInit,
+      headers: {
+        ...requestInit.headers,
+        ...defaultHeaders,
+      },
+      body: body,
+    });
+
+    const endpoint = `${requestInit.method ?? "GET"} ${path}`;
+
+    if (!response.ok) {
+      const bodyString = await response.text();
+      throw RequestExecutorError.serverError(endpoint, response.status, bodyString);
+    }
+
+    const wrapperParseResult = ResponseWrapper.safeParse(await response.json());
+    if (!wrapperParseResult.success) {
+      throw RequestExecutorError.responseParsingError(endpoint, wrapperParseResult.error);
+    }
+
+    const responseParseResult = schema.safeParse(wrapperParseResult.data.result);
+    if (!responseParseResult.success) {
+      throw RequestExecutorError.responseParsingError(endpoint, responseParseResult.error);
+    }
+
+    return responseParseResult.data;
+  }
+
+  private fullUrl(path: string): string {
+    return `https://${this.testServerConfig.host}/api/v2${path}`;
+  }
+}