@gitpod/gitpod-protocol 0.1.5-sh-ace-test.0 → 0.1.5-siddhant-k-code-allow-github-prebuilds-10358.2

package/src/accounting-protocol.ts

@@ -0,0 +1,244 @@
+/**
+ * Copyright (c) 2021 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License.AGPL.txt in the project root for license information.
+ */
+
+import { v4 as uuidv4 } from "uuid";
+import { User } from "./protocol";
+import { oneMonthLater } from "./util/timeutil";
+
+/*
+ * Subscription and acocunting data
+ */
+export interface AccountEntry {
+    uid: string;
+
+    userId: string;
+
+    /** [hours] */
+    amount: number;
+
+    /**
+     * credit: start of validity,
+     * session: end of (split-) session
+     */
+    date: string;
+
+    /**
+     * debits (session, expiry, loss): relation to credit
+     */
+    creditId?: string;
+
+    /**
+     * credit: end of validity
+     */
+    expiryDate?: string; // exclusive
+
+    kind: AccountEntryKind;
+
+    /**
+     * credit: amount - accounted debits
+     * [hours]
+     */
+    remainingAmount?: number;
+
+    description?: object;
+}
+export namespace AccountEntry {
+    export function create<T extends AccountEntry>(entry: Omit<T, "uid">): T {
+        const result = entry as T;
+        result.uid = uuidv4();
+        return result;
+    }
+}
+
+export type DebitAccountEntryKind = "session" | "expiry" | "loss";
+export type AccountEntryKind = "credit" | DebitAccountEntryKind | "carry" | "open";
+
+export interface Credit extends AccountEntry {
+    kind: "credit";
+    expiryDate: string;
+}
+export type Debit = LossDebit | ExpiryDebit | SessionDebit;
+export interface LossDebit extends AccountEntry {
+    kind: "loss";
+}
+export interface ExpiryDebit extends AccountEntry {
+    kind: "expiry";
+    creditId: undefined;
+}
+export interface SessionDebit extends AccountEntry {
+    kind: DebitAccountEntryKind;
+    creditId: string;
+}
+
+export type AccountEntryDescription = SessionDescription | CreditDescription;
+export interface CreditDescription {
+    subscriptionId: string;
+    planId: string;
+}
+export namespace CreditDescription {
+    export function is(obj: any): obj is CreditDescription {
+        return !!obj && obj.hasOwnProperty("subscriptionId") && obj.hasOwnProperty("planId");
+    }
+}
+export interface SessionDescription {
+    contextTitle: string;
+    contextUrl: string;
+    workspaceId: string;
+    workspaceInstanceId: string;
+}
+export namespace SessionDescription {
+    export function is(obj: any): obj is SessionDescription {
+        return (
+            !!obj &&
+            obj.hasOwnProperty("contextTitle") &&
+            obj.hasOwnProperty("contextUrl") &&
+            obj.hasOwnProperty("workspaceId") &&
+            obj.hasOwnProperty("workspaceInstanceId")
+        );
+    }
+}
+
+/**
+ * - The earliest subscription may start with User.creationDate
+ * - There may be multiple Gitpod subscriptions for a user at any given time
+ * - The dates form an interval of the form: [startDate, endDate)
+ * - Subscriptions that directly map to a Chargebee plan have their paymentReference set and MAY carry additional paymentData (UserPaidSubscription)
+ * - Subscriptions that are assigned to a user through a Team Subscription carry a teamSubscriptionSlotId (AssignedTeamSubscription)
+ */
+export interface Subscription {
+    uid: string;
+    userId: string;
+    startDate: string; // inclusive
+    /** When the subscription will end (must be >= cancellationDate!) */
+    endDate?: string; // exclusive
+    /** When the subscription was cancelled */
+    cancellationDate?: string; // exclusive
+    /** Number of granted hours */
+    amount: number;
+    /** Number of granted hours for the first month: If this is set, use this value for the first month */
+    firstMonthAmount?: number;
+    planId?: string;
+    paymentReference?: string;
+    paymentData?: PaymentData;
+    teamSubscriptionSlotId?: string;
+    teamMembershipId?: string;
+    /** marks the subscription as deleted */
+    deleted?: boolean;
+}
+
+export interface SubscriptionAndUser extends Subscription {
+    user: User;
+}
+
+export interface PaymentData {
+    /** Marks the date as of which the _switch_ is effective. */
+    downgradeDate?: string;
+    /** Determines the new plan the dowgrade is targeted against (optional for backwards compatibility) */
+    newPlan?: string;
+}
+
+export interface UserPaidSubscription extends Subscription {
+    paymentReference: string;
+    paymentData?: PaymentData;
+}
+export namespace UserPaidSubscription {
+    export function is(data: any): data is UserPaidSubscription {
+        return !!data && data.hasOwnProperty("paymentReference");
+    }
+}
+
+export interface AssignedTeamSubscription extends Subscription {
+    teamSubscriptionSlotId: string;
+}
+export namespace AssignedTeamSubscription {
+    export function is(data: any): data is AssignedTeamSubscription {
+        return !!data && data.hasOwnProperty("teamSubscriptionSlotId");
+    }
+}
+
+export interface AssignedTeamSubscription2 extends Subscription {
+    teamMembershipId: string;
+}
+export namespace AssignedTeamSubscription2 {
+    export function is(data: any): data is AssignedTeamSubscription2 {
+        return typeof data === "object" && data.hasOwnProperty("teamMembershipId");
+    }
+}
+
+export namespace Subscription {
+    export function create(newSubscription: Omit<Subscription, "uid">) {
+        const subscription = newSubscription as Subscription;
+        subscription.uid = uuidv4();
+        return subscription;
+    }
+    export function cancelSubscription(s: Subscription, cancellationDate: string, endDate?: string) {
+        s.endDate = endDate || cancellationDate;
+        s.cancellationDate = cancellationDate;
+    }
+    export function isSame(s1: Subscription | undefined, s2: Subscription | undefined): boolean {
+        return (
+            !!s1 &&
+            !!s2 &&
+            s1.userId === s2.userId &&
+            s1.planId === s2.planId &&
+            s1.startDate === s2.startDate &&
+            s1.endDate === s2.endDate &&
+            s1.amount === s2.amount &&
+            s1.cancellationDate === s2.cancellationDate &&
+            s1.deleted === s2.deleted &&
+            ((s1.paymentData === undefined && s2.paymentData === undefined) ||
+                (!!s1.paymentData &&
+                    !!s2.paymentData &&
+                    s1.paymentData.downgradeDate === s2.paymentData.downgradeDate &&
+                    s1.paymentData.newPlan === s2.paymentData.newPlan))
+        );
+    }
+    export function isActive(s: Subscription, date: string): boolean {
+        return s.startDate <= date && (s.endDate === undefined || date < s.endDate);
+    }
+    export function isCancelled(s: Subscription, date: string): boolean {
+        return (!!s.cancellationDate && s.cancellationDate < date) || (!!s.endDate && s.endDate < date); // This edge case is meant to handle bad data: If for whatever reason cancellationDate has not been set: treat endDate as such
+    }
+    export function isDowngraded(s: Subscription) {
+        return s.paymentData && s.paymentData.downgradeDate;
+    }
+    export function calculateCurrentPeriod(startDate: string, now: Date) {
+        let nextStartDate = startDate;
+        do {
+            startDate = nextStartDate;
+            nextStartDate = oneMonthLater(startDate, new Date(startDate).getDate());
+        } while (nextStartDate < now.toISOString());
+        return { startDate, endDate: nextStartDate };
+    }
+}
+
+export type MaybeSubscription = Subscription | undefined;
+
+export interface Period {
+    startDate: string; // inclusive
+    endDate: string; // exclusive
+}
+
+export type MaybePeriod = Period | undefined;
+
+export type AccountEntryFixedPeriod = Omit<AccountEntry, "uid"> & { expiryDate: string };
+export interface AccountStatement extends Period {
+    userId: string;
+    /**
+     * The subscriptions that have not been cancelled yet at the end of the period
+     */
+    subscriptions: Subscription[];
+    credits: Credit[];
+    debits: Debit[];
+    /** Remaining valid hours (accumulated from credits) */
+    remainingHours: RemainingHours;
+}
+export type RemainingHours = number | "unlimited";
+
+export interface CreditAlert {
+    userId: string;
+    remainingUsageHours: number;
+}

package/src/admin-protocol.ts

@@ -1,63 +1,111 @@
 /**
- * Copyright (c) 2020 TypeFox GmbH. All rights reserved.
+ * Copyright (c) 2020 Gitpod GmbH. All rights reserved.
  * Licensed under the GNU Affero General Public License (AGPL).
- * See License-AGPL.txt in the project root for license information.
+ * See License.AGPL.txt in the project root for license information.
  */
 
 import { User, Workspace, NamedWorkspaceFeatureFlag } from "./protocol";
-import { Without } from "./util/without";
+import { BlockedRepository } from "./blocked-repositories-protocol";
+import { FindPrebuildsParams } from "./gitpod-service";
+import { Project, Team, PrebuildWithStatus, TeamMemberInfo, TeamMemberRole } from "./teams-projects-protocol";
 import { WorkspaceInstance, WorkspaceInstancePhase } from "./workspace-instance";
 import { RoleOrPermission } from "./permission";
+import { AccountStatement } from "./accounting-protocol";
+import { BillingMode } from "./billing-mode";
+import { CostCenterJSON, ListUsageRequest, ListUsageResponse } from "./usage";
+import { InstallationAdminSettings, TelemetryData } from "./installation-admin-protocol";
 
 export interface AdminServer {
     adminGetUsers(req: AdminGetListRequest<User>): Promise<AdminGetListResult<User>>;
     adminGetUser(id: string): Promise<User>;
     adminBlockUser(req: AdminBlockUserRequest): Promise<User>;
+    adminDeleteUser(id: string): Promise<void>;
+    adminVerifyUser(id: string): Promise<User>;
     adminModifyRoleOrPermission(req: AdminModifyRoleOrPermissionRequest): Promise<User>;
     adminModifyPermanentWorkspaceFeatureFlag(req: AdminModifyPermanentWorkspaceFeatureFlagRequest): Promise<User>;
 
+    adminCreateBlockedRepository(urlRegexp: string, blockUser: boolean): Promise<BlockedRepository>;
+    adminDeleteBlockedRepository(id: number): Promise<void>;
+    adminGetBlockedRepositories(
+        req: AdminGetListRequest<BlockedRepository>,
+    ): Promise<AdminGetListResult<BlockedRepository>>;
+
+    adminGetTeamMembers(teamId: string): Promise<TeamMemberInfo[]>;
+    adminGetTeams(req: AdminGetListRequest<Team>): Promise<AdminGetListResult<Team>>;
+    adminGetTeamById(id: string): Promise<Team | undefined>;
+    adminSetTeamMemberRole(teamId: string, userId: string, role: TeamMemberRole): Promise<void>;
+
     adminGetWorkspaces(req: AdminGetWorkspacesRequest): Promise<AdminGetListResult<WorkspaceAndInstance>>;
     adminGetWorkspace(id: string): Promise<WorkspaceAndInstance>;
     adminForceStopWorkspace(id: string): Promise<void>;
+    adminRestoreSoftDeletedWorkspace(id: string): Promise<void>;
+
+    adminGetProjectsBySearchTerm(req: AdminGetListRequest<Project>): Promise<AdminGetListResult<Project>>;
+    adminGetProjectById(id: string): Promise<Project | undefined>;
 
+    adminFindPrebuilds(params: FindPrebuildsParams): Promise<PrebuildWithStatus[]>;
     adminSetLicense(key: string): Promise<void>;
+
+    adminGetAccountStatement(userId: string): Promise<AccountStatement>;
+    adminSetProfessionalOpenSource(userId: string, shouldGetProfOSS: boolean): Promise<void>;
+    adminIsStudent(userId: string): Promise<boolean>;
+    adminAddStudentEmailDomain(userId: string, domain: string): Promise<void>;
+    adminGrantExtraHours(userId: string, extraHours: number): Promise<void>;
+    adminGetBillingMode(attributionId: string): Promise<BillingMode>;
+
+    adminGetSettings(): Promise<InstallationAdminSettings>;
+    adminUpdateSettings(settings: InstallationAdminSettings): Promise<void>;
+
+    adminGetCostCenter(attributionId: string): Promise<CostCenterJSON | undefined>;
+    adminSetUsageLimit(attributionId: string, usageLimit: number): Promise<void>;
+
+    adminListUsage(req: ListUsageRequest): Promise<ListUsageResponse>;
+    adminAddUsageCreditNote(attributionId: string, credits: number, note: string): Promise<void>;
+    adminGetUsageBalance(attributionId: string): Promise<number>;
+
+    // Admin Settings
+    adminGetSettings(): Promise<InstallationAdminSettings>;
+    adminUpdateSettings(settings: InstallationAdminSettings): Promise<void>;
+    adminGetTelemetryData(): Promise<TelemetryData>;
 }
 
 export interface AdminGetListRequest<T> {
-    offset: number
-    limit: number
-    orderBy: keyof T
-    orderDir: "asc" | "desc"
+    offset: number;
+    limit: number;
+    orderBy: keyof T;
+    orderDir: "asc" | "desc";
     searchTerm?: string;
 }
 
 export interface AdminGetListResult<T> {
-    total: number
-    rows: T[]
+    total: number;
+    rows: T[];
 }
 
 export interface AdminBlockUserRequest {
-    id: string
-    blocked: boolean
+    id: string;
+    blocked: boolean;
 }
 
 export interface AdminModifyRoleOrPermissionRequest {
     id: string;
     rpp: {
-        r: RoleOrPermission
-        add: boolean
-    }[]
+        r: RoleOrPermission;
+        add: boolean;
+    }[];
 }
 
 export interface AdminModifyPermanentWorkspaceFeatureFlagRequest {
     id: string;
     changes: {
-        featureFlag: NamedWorkspaceFeatureFlag
-        add: boolean
-    }[]
+        featureFlag: NamedWorkspaceFeatureFlag;
+        add: boolean;
+    }[];
 }
 
-export interface WorkspaceAndInstance extends Without<Workspace, "id"|"creationTime">, Without<WorkspaceInstance, "id"|"creationTime"> {
+export interface WorkspaceAndInstance
+    extends Omit<Workspace, "id" | "creationTime">,
+        Omit<WorkspaceInstance, "id" | "creationTime"> {
     workspaceId: string;
     workspaceCreationTime: string;
     instanceId: string;
@@ -65,6 +113,33 @@ export interface WorkspaceAndInstance extends Without<Workspace, "id"|"creationT
     phase: WorkspaceInstancePhase;
 }
 
-export interface AdminGetWorkspacesRequest extends AdminGetListRequest<WorkspaceAndInstance> {
-    ownerId?: string
-}
+export namespace WorkspaceAndInstance {
+    export function toWorkspace(wai: WorkspaceAndInstance): Workspace {
+        return {
+            id: wai.workspaceId,
+            creationTime: wai.workspaceCreationTime,
+            ...wai,
+        };
+    }
+
+    export function toInstance(wai: WorkspaceAndInstance): WorkspaceInstance | undefined {
+        if (!wai.instanceId) {
+            return undefined;
+        }
+        return {
+            id: wai.instanceId,
+            creationTime: wai.instanceCreationTime,
+            ...wai,
+        };
+    }
+}
+
+export type AdminGetWorkspacesRequest = AdminGetListRequest<WorkspaceAndInstance> & AdminGetWorkspacesQuery;
+/** The fields are meant to be used either OR (not combined) */
+export type AdminGetWorkspacesQuery = {
+    /** we use this field in case we have a UUIDv4 and don't know whether it's an (old) workspace or instance id */
+    instanceIdOrWorkspaceId?: string;
+    instanceId?: string;
+    workspaceId?: string;
+    ownerId?: string;
+};

package/src/analytics.ts

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2021 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License.AGPL.txt in the project root for license information.
+ */
+
+export const IAnalyticsWriter = Symbol("IAnalyticsWriter");
+
+type Identity =
+    | { userId: string | number; anonymousId?: string | number }
+    | { userId?: string | number; anonymousId: string | number };
+
+interface Message {
+    messageId?: string;
+}
+
+export type IdentifyMessage = Message &
+    Identity & {
+        traits?: any;
+        timestamp?: Date;
+        context?: any;
+    };
+
+export type TrackMessage = Message &
+    Identity & {
+        event: string;
+        properties?: any;
+        timestamp?: Date;
+        context?: any;
+    };
+
+export type PageMessage = Message &
+    Identity & {
+        properties?: any;
+        timestamp?: Date;
+        context?: any;
+    };
+
+export type RemoteTrackMessage = Omit<TrackMessage, "timestamp" | "userId">;
+export type RemotePageMessage = Omit<PageMessage, "timestamp" | "userId"> & {
+    includePII?: boolean;
+};
+
+export type RemoteIdentifyMessage = Omit<IdentifyMessage, "timestamp" | "userId">;
+
+export interface IAnalyticsWriter {
+    identify(msg: IdentifyMessage): void;
+
+    track(msg: TrackMessage): void;
+
+    page(msg: PageMessage): void;
+}

package/src/attribution.ts

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2022 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License.AGPL.txt in the project root for license information.
+ */
+
+import { User } from "./protocol";
+import { Team } from "./teams-projects-protocol";
+
+export type AttributionId = UserAttributionId | TeamAttributionId;
+export type AttributionTarget = "user" | "team";
+
+export interface UserAttributionId {
+    kind: "user";
+    userId: string;
+}
+export interface TeamAttributionId {
+    kind: "team";
+    teamId: string;
+}
+
+export namespace AttributionId {
+    const SEPARATOR = ":";
+
+    export function create(userOrTeam: User | Team): AttributionId {
+        if (User.is(userOrTeam)) {
+            return { kind: "user", userId: userOrTeam.id };
+        } else {
+            return { kind: "team", teamId: userOrTeam.id };
+        }
+    }
+
+    export function parse(s: string): UserAttributionId | TeamAttributionId | undefined {
+        if (!s) {
+            return undefined;
+        }
+        const parts = s.split(":");
+        if (parts.length !== 2) {
+            return undefined;
+        }
+        switch (parts[0]) {
+            case "user":
+                return { kind: "user", userId: parts[1] };
+            case "team":
+                return { kind: "team", teamId: parts[1] };
+            default:
+                return undefined;
+        }
+    }
+
+    export function render(id: AttributionId): string {
+        switch (id.kind) {
+            case "user":
+                return `user${SEPARATOR}${id.userId}`;
+            case "team":
+                return `team${SEPARATOR}${id.teamId}`;
+        }
+    }
+
+    export function equals(a: AttributionId, b: AttributionId): boolean {
+        return render(a) === render(b);
+    }
+}

package/src/auth.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2021 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License.AGPL.txt in the project root for license information.
+ */
+
+export interface SelectAccountPayload {
+    currentUser: {
+        name: string;
+        avatarUrl: string;
+        authHost: string;
+        authName: string;
+        authProviderType: string;
+    };
+    otherUser: {
+        name: string;
+        avatarUrl: string;
+        authHost: string;
+        authName: string;
+        authProviderType: string;
+    };
+}
+export namespace SelectAccountPayload {
+    export function is(data: any): data is SelectAccountPayload {
+        return typeof data === "object" && "currentUser" in data && "otherUser" in data;
+    }
+}

package/src/billing-mode.ts

@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2022 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License.AGPL.txt in the project root for license information.
+ */
+
+/**
+ * BillingMode is used to answer the following questions:
+ *  - Should UI piece x be displayed for this user/team? (getBillingModeForUser/Team)
+ *  - What model should be used to limit this workspace's capabilities (mayStartWorkspace, setTimeout, workspace class, etc...) (getBillingMode(workspaceInstance.attributionId))
+ *  - How is a workspace session charged for? (getBillingMode(workspaceInstance.attributionId))
+ */
+export type BillingMode = None | Chargebee | UsageBased;
+export namespace BillingMode {
+    export const NONE: None = {
+        mode: "none",
+    };
+
+    /** Incl. upgrade and status */
+    export function showUsageBasedBilling(billingMode?: BillingMode): boolean {
+        if (!billingMode) {
+            return false;
+        }
+        return (
+            billingMode.mode === "usage-based" || (billingMode.mode === "chargebee" && !!billingMode.canUpgradeToUBB)
+        );
+    }
+
+    export function showTeamSubscriptionUI(billingMode?: BillingMode): boolean {
+        if (!billingMode) {
+            return false;
+        }
+        return (
+            billingMode.mode === "chargebee" ||
+            (billingMode.mode === "usage-based" && !!billingMode.hasChargebeeTeamSubscription)
+        );
+    }
+
+    export function canSetWorkspaceClass(billingMode?: BillingMode): boolean {
+        if (!billingMode) {
+            return false;
+        }
+
+        // if has any Stripe subscription, either directly or per team, OR we're running on a license
+        return billingMode.mode === "usage-based" || billingMode.mode === "none";
+    }
+
+    export function canSetCostCenter(billingMode: BillingMode): boolean {
+        // if has any Stripe Subscription, either directly or per team
+        return billingMode.mode === "usage-based";
+    }
+}
+
+/** Payment is disabled */
+interface None {
+    mode: "none";
+}
+
+/** Sessions is handled with old subscription logic based on Chargebee */
+interface Chargebee {
+    mode: "chargebee";
+
+    /** True iff this is a team, and is based on a paid plan. Currently only set for teams! */
+    paid?: boolean;
+
+    canUpgradeToUBB?: boolean;
+
+    /** Name of team(s) that block switching to usage-based */
+    teamNames?: string[];
+}
+
+/** Session is handld with new usage-based logic */
+interface UsageBased {
+    mode: "usage-based";
+
+    /** True iff this is a team, and is based on a paid plan. Currently only set for teams! */
+    paid?: boolean;
+
+    /** User is already converted, but is member with at least one Chargebee-based "Team Plan" */
+    hasChargebeeTeamPlan?: boolean;
+
+    /** User is already converted, but is member or owner in at least one Chargebee-based "Team Subscription" */
+    hasChargebeeTeamSubscription?: boolean;
+}

package/src/blocked-repositories-protocol.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2022 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License.AGPL.txt in the project root for license information.
+ */
+
+export interface BlockedRepository {
+    id: number;
+    urlRegexp: string;
+    blockUser: boolean;
+    createdAt: string;
+    updatedAt: string;
+}