@gitpod/gitpod-protocol 0.1.5-to-code-reading.1 → 0.1.5-to-monitor-delete.18

package/src/util/timeutil.spec.ts

@@ -4,40 +4,66 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import * as chai from 'chai';
+import * as chai from "chai";
 const expect = chai.expect;
-import { suite, test } from 'mocha-typescript';
-import { oneMonthLater } from './timeutil';
+import { suite, test } from "mocha-typescript";
+import { daysBefore, hoursBefore, oneMonthLater } from "./timeutil";
 
 @suite()
 export class TimeutilSpec {
+    @test
+    testDaysBefore() {
+        const now = new Date().toISOString();
+        expect(daysBefore(now, 2)).to.be.eq(hoursBefore(now, 48));
+    }
 
     @test
     testTimeutil() {
         // targeting a 1st, 1th of Jan => 1st of Feb
-        this.isOneMonthLater(new Date(2000, 0, 1), 1, new Date(2000, 1, 1))
+        this.isOneMonthLater(new Date(2000, 0, 1), 1, new Date(2000, 1, 1));
 
         // targeting a 31th, 30th of Apr => 31st of May
-        this.isOneMonthLater(new Date(2000, 3, 30), 31, new Date(2000, 4, 31))
+        this.isOneMonthLater(new Date(2000, 3, 30), 31, new Date(2000, 4, 31));
 
         // targeting a 31th, 31th of Mar => 30th of Apr
-        this.isOneMonthLater(new Date(2000, 2, 31), 31, new Date(2000, 3, 30))
+        this.isOneMonthLater(new Date(2000, 2, 31), 31, new Date(2000, 3, 30));
 
         // targeting a 30th, 30th of Mar => 30th of Apr
-        this.isOneMonthLater(new Date(2000, 2, 30), 30, new Date(2000, 3, 30))
+        this.isOneMonthLater(new Date(2000, 2, 30), 30, new Date(2000, 3, 30));
 
         // next year
-        this.isOneMonthLater(new Date(2000, 11, 1), 1, new Date(2001, 0, 1))
-        this.isOneMonthLater(new Date(2000, 11, 31), 31, new Date(2001, 0, 31))
+        this.isOneMonthLater(new Date(2000, 11, 1), 1, new Date(2001, 0, 1));
+        this.isOneMonthLater(new Date(2000, 11, 31), 31, new Date(2001, 0, 31));
 
         // Feb
-        this.isOneMonthLater(new Date(2001, 0, 31), 31, new Date(2001, 1, 28))
+        this.isOneMonthLater(new Date(2001, 0, 31), 31, new Date(2001, 1, 28));
         // Feb leap year
-        this.isOneMonthLater(new Date(2000, 0, 31), 31, new Date(2000, 1, 29))
+        this.isOneMonthLater(new Date(2000, 0, 31), 31, new Date(2000, 1, 29));
     }
 
     isOneMonthLater(from: Date, day: number, expectation: Date) {
-        const later = oneMonthLater(from.toISOString(), day)
-        expect(later, `expected ${later} to be equal ${expectation}`).to.be.equal(expectation.toISOString())
+        const later = oneMonthLater(from.toISOString(), day);
+        expect(later, `expected ${later} to be equal ${expectation}`).to.be.equal(expectation.toISOString());
+    }
+
+    @test
+    testDaysBefore2() {
+        const tests: { date: Date; daysEarlier: number; expectation: string }[] = [
+            {
+                date: new Date("2021-07-13T00:00:00.000Z"),
+                daysEarlier: 365,
+                expectation: "2020-07-13T00:00:00.000Z",
+            },
+            {
+                date: new Date("2019-02-01T00:00:00.000Z"),
+                daysEarlier: 365,
+                expectation: "2018-02-01T00:00:00.000Z",
+            },
+        ];
+
+        for (const t of tests) {
+            const actual = daysBefore(t.date.toISOString(), t.daysEarlier);
+            expect(actual).to.equal(t.expectation, `expected ${actual} to be equal ${t.expectation}`);
+        }
     }
-}
+}

package/src/util/timeutil.ts

@@ -24,28 +24,44 @@ export function oneMonthLater(fromDate: string, day?: number): string {
     }
     return later.toISOString();
 }
-export const yearsLater = (fromDate: string, years: number): string => liftDate1(fromDate, (d) => {
-    d.setUTCFullYear(d.getUTCFullYear() + years);
-    return d.toISOString();
-});
+export const yearsLater = (fromDate: string, years: number): string =>
+    liftDate1(fromDate, (d) => {
+        d.setUTCFullYear(d.getUTCFullYear() + years);
+        return d.toISOString();
+    });
 
 // tslint:disable-next-line:no-shadowed-variable
-export const addMillis = (d1: string, millis: number) => liftDate1(d1, (d1) => new Date(d1.getTime() + millis).toISOString());
-export const durationInHours = (d1: string, d2: string) => liftDate(d1, d2, (d1, d2) => millisecondsToHours(d1.getTime() - d2.getTime()));
+export const addMillis = (d1: string, millis: number) =>
+    liftDate1(d1, (d1) => new Date(d1.getTime() + millis).toISOString());
+export const durationInHours = (d1: string, d2: string) =>
+    liftDate(d1, d2, (d1, d2) => millisecondsToHours(d1.getTime() - d2.getTime()));
 export const durationInMillis = (d1: string, d2: string) => liftDate(d1, d2, (d1, d2) => d1.getTime() - d2.getTime());
 // tslint:disable-next-line:no-shadowed-variable
-export const isDateGreaterOrEqual = (d1: string, d2: string): boolean => liftDate(d1, d2, (d1, d2) => d1.getTime() >= d2.getTime());
+export const isDateGreaterOrEqual = (d1: string, d2: string): boolean =>
+    liftDate(d1, d2, (d1, d2) => d1.getTime() >= d2.getTime());
 export const isDateSmallerOrEqual = (d1: string, d2: string | undefined) => !d2 || d1 <= d2;
 export const isDateSmaller = (d1: string, d2: string | undefined) => !d2 || d1 < d2;
-export const oldest = (d1: string, d2: string): string => d1 > d2 ? d1 : d2;
-export const earliest = (d1: string, d2: string): string => d1 < d2 ? d1 : d2;
+export const oldest = (d1: string, d2: string): string => (d1 > d2 ? d1 : d2);
+export const earliest = (d1: string, d2: string): string => (d1 < d2 ? d1 : d2);
 export const orderAsc = (d1: string, d2: string): number => liftDate(d1, d2, (d1, d2) => d1.getTime() - d2.getTime());
 export const liftDate1 = <T>(d1: string, f: (d1: Date) => T): T => f(new Date(d1));
 export const liftDate = <T>(d1: string, d2: string, f: (d1: Date, d2: Date) => T): T => f(new Date(d1), new Date(d2));
 
+export function daysBefore(date: string, days: number): string {
+    const result = new Date(date);
+    result.setDate(result.getDate() - days);
+    return result.toISOString();
+}
+
+export function hoursBefore(date: string, hours: number): string {
+    const result = new Date(date);
+    result.setHours(result.getHours() - hours);
+    return result.toISOString();
+}
+
 export function hoursLater(date: string, hours: number): string {
-    const result = new Date(date)
-    result.setHours(result.getHours() + hours)
+    const result = new Date(date);
+    result.setHours(result.getHours() + hours);
     return result.toISOString();
 }
 

package/src/util/tracing.spec.ts

@@ -4,28 +4,31 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import { suite, test } from "mocha-typescript"
-import * as chai from "chai"
+import { suite, test } from "mocha-typescript";
+import * as chai from "chai";
 import { TraceContext } from "./tracing";
 import { MockTracer } from "opentracing";
 
-const expect = chai.expect
-
-@suite class TestTracing {
+const expect = chai.expect;
 
+@suite
+class TestTracing {
     @test public async testTracingContext_addNestedTags() {
         const tracer = new MockTracer();
-        const span = tracer.startSpan('testTracingContext_addNestedTags');
-        TraceContext.addNestedTags({ span }, {
-            rpc: {
-                system: "jsonrpc",
-                jsonrpc: {
-                    version: "1.0",
-                    method: "test",
-                    parameters: ["abc", "def"],
+        const span = tracer.startSpan("testTracingContext_addNestedTags");
+        TraceContext.addNestedTags(
+            { span },
+            {
+                rpc: {
+                    system: "jsonrpc",
+                    jsonrpc: {
+                        version: "1.0",
+                        method: "test",
+                        parameters: ["abc", "def"],
+                    },
                 },
             },
-        });
+        );
 
         const mockSpan = tracer.report().spans[0];
         expect(mockSpan.tags()).to.deep.equal({
@@ -39,13 +42,16 @@ const expect = chai.expect
 
     @test public async testTracingContext_addNestedTags_null() {
         const tracer = new MockTracer();
-        const span = tracer.startSpan('testTracingContext_addNestedTags_null');
-        TraceContext.addNestedTags({ span }, {
-            someShape: {
-                thisIsNull: null,
-                thisIsUndefined: undefined,
+        const span = tracer.startSpan("testTracingContext_addNestedTags_null");
+        TraceContext.addNestedTags(
+            { span },
+            {
+                someShape: {
+                    thisIsNull: null,
+                    thisIsUndefined: undefined,
+                },
             },
-        });
+        );
 
         const mockSpan = tracer.report().spans[0];
         expect(mockSpan.tags()).to.deep.equal({
@@ -56,7 +62,7 @@ const expect = chai.expect
 
     @test public async testTracingContext_addJsonRPCParameters() {
         const tracer = new MockTracer();
-        const span = tracer.startSpan('testTracingContext_addJsonRPCParameters');
+        const span = tracer.startSpan("testTracingContext_addJsonRPCParameters");
         const ctx = { span };
         TraceContext.addJsonRPCParameters(ctx, {
             one: "one",
@@ -78,6 +84,5 @@ const expect = chai.expect
             "rpc.system": "jsonrpc",
         });
     }
-
 }
-module.exports = new TestTracing()
+module.exports = new TestTracing();

package/src/util/tracing.ts

@@ -4,35 +4,32 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-
-import * as opentracing from 'opentracing';
-import { TracingConfig, initTracerFromEnv } from 'jaeger-client';
-import { Sampler, SamplingDecision } from './jaeger-client-types';
-import { followsFrom, initGlobalTracer } from 'opentracing';
-import { injectable } from 'inversify';
-import { ResponseError } from 'vscode-jsonrpc';
-import { log, LogContext } from './logging';
+import * as opentracing from "opentracing";
+import { TracingConfig, initTracerFromEnv } from "jaeger-client";
+import { Sampler, SamplingDecision } from "./jaeger-client-types";
+import { initGlobalTracer } from "opentracing";
+import { injectable } from "inversify";
+import { ResponseError } from "vscode-jsonrpc";
+import { log, LogContext } from "./logging";
 
 export interface TraceContext {
-    span?: opentracing.Span
+    span?: opentracing.Span;
 }
 export type TraceContextWithSpan = TraceContext & {
-    span: opentracing.Span
-}
-
+    span: opentracing.Span;
+};
 
 export namespace TraceContext {
-    export function startSpan(operation: string, parentCtx?: TraceContext, ...referencedSpans: (opentracing.Span | undefined)[]): opentracing.Span {
+    export function startSpan(operation: string, parentCtx?: TraceContext): opentracing.Span {
         const options: opentracing.SpanOptions = {};
-        if (parentCtx && parentCtx.span && !!parentCtx.span.context().toSpanId()) {
-            options.childOf = parentCtx.span;
-        }
-        if (referencedSpans) {
-            // note: allthough followsForm's type says it takes 'opentracing.Span | opentracing.SpanContext', it only works with SpanContext (typing mismatch)
-            // note2: we need to filter out debug spans (spanId === "")
-            options.references = referencedSpans.filter(s => s !== undefined)
-                .filter(s => !!s!.context().toSpanId())
-                .map(s => followsFrom(s!.context()));
+
+        // references should contain span id.
+        // cf. https://github.com/jaegertracing/jaeger-client-node/issues/432
+        if (!!parentCtx?.span) {
+            const ctx = parentCtx?.span?.context();
+            if (ctx && !!ctx.toTraceId() && !!ctx.toSpanId()) {
+                options.references = [opentracing.followsFrom(ctx)];
+            }
         }
 
         return opentracing.globalTracer().startSpan(operation, options);
@@ -43,18 +40,18 @@ export namespace TraceContext {
         return { span };
     }
 
-    export function withSpan(operation: string, callback: () => void, ctx?: TraceContext, ...referencedSpans: (opentracing.Span | undefined)[]): void {
+    export function withSpan(operation: string, callback: (ctx: TraceContext) => void, ctx?: TraceContext): void {
         // if we don't have a parent span, don't create a trace here as those <trace-without-root-spans> are not useful.
         if (!ctx || !ctx.span || !ctx.span.context()) {
-            callback();
+            callback({});
             return;
         }
 
-        const span = TraceContext.startSpan(operation, ctx, ...referencedSpans);
+        const span = TraceContext.startSpan(operation, ctx);
         try {
-            callback();
+            callback({ span });
         } catch (e) {
-            TraceContext.setError({span}, e);
+            TraceContext.setError({ span }, e);
             throw e;
         } finally {
             span.finish();
@@ -92,7 +89,12 @@ export namespace TraceContext {
         addNestedTags(ctx, tags);
     }
 
-    export function setJsonRPCError(ctx: TraceContext, method: string, err: ResponseError<any>, withStatusCode: boolean = false) {
+    export function setJsonRPCError(
+        ctx: TraceContext,
+        method: string,
+        err: ResponseError<any>,
+        withStatusCode: boolean = false,
+    ) {
         if (!ctx.span) {
             return;
         }
@@ -159,7 +161,7 @@ export namespace TraceContext {
         if (!ctx.span) {
             return;
         }
-        const namespace = _namespace ? `${_namespace}.` : '';
+        const namespace = _namespace ? `${_namespace}.` : "";
 
         try {
             for (const k of Object.keys(keyValueMap)) {
@@ -188,7 +190,6 @@ export namespace TraceContext {
 
 @injectable()
 export class TracingManager {
-
     public setup(serviceName: string, opts?: CustomTracerOpts) {
         initGlobalTracer(this.getTracerForService(serviceName, opts));
     }
@@ -197,16 +198,16 @@ export class TracingManager {
         const config: TracingConfig = {
             disable: false,
             reporter: {
-                logSpans: false
+                logSpans: false,
             },
             serviceName,
-        }
+        };
         const t = initTracerFromEnv(config, {
             logger: console,
             tags: {
-                'service.build.commit': process.env.GITPOD_BUILD_GIT_COMMIT,
-                'service.build.version': process.env.GITPOD_BUILD_VERSION,
-            }
+                "service.build.commit": process.env.GITPOD_BUILD_GIT_COMMIT,
+                "service.build.version": process.env.GITPOD_BUILD_VERSION,
+            },
         });
 
         if (opts) {
@@ -216,24 +217,22 @@ export class TracingManager {
         }
         return t;
     }
-
 }
 
 export interface CustomTracerOpts {
-    perOpSampling?: PerOperationSampling
+    perOpSampling?: PerOperationSampling;
 }
 
-
 // has to conform to https://github.com/jaegertracing/jaeger-client-node/blob/0042b1c0a0796bb655eb93e77ff76ab5e94c2bb6/src/_flow/sampler-thrift.js#L32
 export interface PerOperationSampling {
-    [key: string]: boolean
+    [key: string]: boolean;
 }
 
 export class PerOperationSampler implements Sampler {
     constructor(protected readonly fallback: Sampler, protected readonly strategies: PerOperationSampling) {}
 
     name(): string {
-        return 'PerOperationSampler';
+        return "PerOperationSampler";
     }
 
     toString(): string {
@@ -273,7 +272,7 @@ export class PerOperationSampler implements Sampler {
         return false; // TODO equal should be removed
     }
 
-    close(callback: ()=>void): void {
+    close(callback: () => void): void {
         // all nested samplers are of simple types, so we do not need to Close them
         if (callback) {
             callback();
@@ -282,18 +281,23 @@ export class PerOperationSampler implements Sampler {
 }
 
 // Augment interfaces with an leading parameter "TraceContext" on every method
-type IsValidArg<T> = T extends object ? keyof T extends never ? false : true : true;
-type AddTraceContext<T> =
-    T extends (a: infer A, b: infer B, c: infer C, d: infer D, e: infer E, f: infer F) => infer R ? (
-        IsValidArg<F> extends true ? (ctx: TraceContextWithSpan, a: A, b: B, c: C, d: D, e: E, f: F) => R :
-        IsValidArg<E> extends true ? (ctx: TraceContextWithSpan, a: A, b: B, c: C, d: D, e: E) => R :
-        IsValidArg<D> extends true ? (ctx: TraceContextWithSpan, a: A, b: B, c: C, d: D) => R :
-        IsValidArg<C> extends true ? (ctx: TraceContextWithSpan, a: A, b: B, c: C) => R :
-        IsValidArg<B> extends true ? (ctx: TraceContextWithSpan, a: A, b: B) => R :
-        IsValidArg<A> extends true ? (ctx: TraceContextWithSpan, a: A) => R :
-        (ctx: TraceContextWithSpan) => Promise<R>
-    ) : never;
+type IsValidArg<T> = T extends object ? (keyof T extends never ? false : true) : true;
+type AddTraceContext<T> = T extends (a: infer A, b: infer B, c: infer C, d: infer D, e: infer E, f: infer F) => infer R
+    ? IsValidArg<F> extends true
+        ? (ctx: TraceContextWithSpan, a: A, b: B, c: C, d: D, e: E, f: F) => R
+        : IsValidArg<E> extends true
+        ? (ctx: TraceContextWithSpan, a: A, b: B, c: C, d: D, e: E) => R
+        : IsValidArg<D> extends true
+        ? (ctx: TraceContextWithSpan, a: A, b: B, c: C, d: D) => R
+        : IsValidArg<C> extends true
+        ? (ctx: TraceContextWithSpan, a: A, b: B, c: C) => R
+        : IsValidArg<B> extends true
+        ? (ctx: TraceContextWithSpan, a: A, b: B) => R
+        : IsValidArg<A> extends true
+        ? (ctx: TraceContextWithSpan, a: A) => R
+        : (ctx: TraceContextWithSpan) => Promise<R>
+    : never;
 
 export type InterfaceWithTraceContext<T> = {
-    [P in keyof T]: AddTraceContext<T[P]>
-};
+    [P in keyof T]: AddTraceContext<T[P]>;
+};

package/src/util/workspace-port-authentication.ts

@@ -5,16 +5,13 @@
  */
 
 /**
-* These cookies are set in the Theia frontend. This pattern is relied upon in:
-*  - proxy:
-*    - to filter it out on port locations
-*    - to forward it to the server for authentication
-*  - server:
-*    - to authenticate access to port locations
-*/
-export const worspacePortAuthCookieName = function(host: string, workspaceId: string): string {
-    return host
-        .replace(/https?/, '')
-        .replace(/[\W_]+/g, "_")
-        + `_ws_${workspaceId}_port_auth_`;
-};
+ * These cookies are set in the Theia frontend. This pattern is relied upon in:
+ *  - proxy:
+ *    - to filter it out on port locations
+ *    - to forward it to the server for authentication
+ *  - server:
+ *    - to authenticate access to port locations
+ */
+export const worspacePortAuthCookieName = function (host: string, workspaceId: string): string {
+    return host.replace(/https?/, "").replace(/[\W_]+/g, "_") + `_ws_${workspaceId}_port_auth_`;
+};

package/src/webhook-event.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 WebhookEvent {
+    id: string;
+    creationTime: string;
+    type: "push" | string;
+
+    /**
+     * Typically the webhook installer is referenced here.
+     */
+    authorizedUserId?: string;
+
+    /**
+     * webhook event's payload
+     */
+    rawEvent: string;
+
+    /**
+     * The general status of the received webhook event.
+     */
+    status: WebhookEvent.Status;
+
+    /**
+     * Optional message to help understand errors with handling events.
+     */
+    message?: string;
+
+    /**
+     * If the webhook event is considered to trigger a prebuild, the `prebuildStatus`
+     * contains a more specific status.
+     */
+    prebuildStatus?: WebhookEvent.PrebuildStatus;
+
+    /**
+     * If `prebuildStatus` is `prebuild_triggered` this points to a prebuild.
+     */
+    prebuildId?: string;
+
+    projectId?: string;
+
+    cloneUrl?: string;
+
+    branch?: string;
+
+    commit?: string;
+}
+
+export namespace WebhookEvent {
+    export type Status = "received" | "dismissed_unauthorized" | "ignored" | "processed";
+    export type PrebuildStatus = "ignored_unconfigured" | "prebuild_trigger_failed" | "prebuild_triggered";
+}

package/src/workspace-class.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 SupportedWorkspaceClass {
+    id: string;
+    category: string;
+    displayName: string;
+    description: string;
+    powerups: number;
+    isSelected: boolean;
+}

package/src/workspace-cluster.ts

@@ -4,10 +4,10 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import * as fs from 'fs';
-import { filePathTelepresenceAware } from './env';
+import * as fs from "fs";
+import { filePathTelepresenceAware } from "./env";
 import { DeepPartial } from "./util/deep-partial";
-import { PermissionName } from './permission';
+import { PermissionName } from "./permission";
 
 export interface WorkspaceCluster {
     // Name of the workspace cluster.
@@ -15,6 +15,10 @@ export interface WorkspaceCluster {
     // Must be identical to the installationShortname of the cluster it represents!
     name: string;
 
+    // The name of the application cluster to which this cluster should be registered.
+    // The name can be at most 60 characters.
+    applicationCluster: string;
+
     // URL of the cluster's ws-manager API
     url: string;
 
@@ -35,9 +39,6 @@ export interface WorkspaceCluster {
 
     // An optional set of constraints that limit who can start workspaces on the cluster
     admissionConstraints?: AdmissionConstraint[];
-
-    // An optional set of admission preferences that guide cluster selection
-    admissionPreferences?: AdmissionPreference[];
 }
 
 export type WorkspaceClusterState = "available" | "cordoned" | "draining";
@@ -50,19 +51,31 @@ export interface TLSConfig {
     crt: string;
 }
 export namespace TLSConfig {
-    export const loadFromBase64File = (path: string): string => fs.readFileSync(filePathTelepresenceAware(path)).toString("base64");
+    export const loadFromBase64File = (path: string): string =>
+        fs.readFileSync(filePathTelepresenceAware(path)).toString("base64");
 }
 export type WorkspaceClusterWoTLS = Omit<WorkspaceCluster, "tls">;
 export type WorkspaceManagerConnectionInfo = Pick<WorkspaceCluster, "name" | "url" | "tls">;
 
-export type AdmissionConstraint = AdmissionConstraintFeaturePreview | AdmissionConstraintHasRole | AdmissionConstraintHasUserLevel;
+export type AdmissionConstraint =
+    | AdmissionConstraintFeaturePreview
+    | AdmissionConstraintHasPermission
+    | AdmissionConstraintHasClass;
 export type AdmissionConstraintFeaturePreview = { type: "has-feature-preview" };
-export type AdmissionConstraintHasRole = { type: "has-permission", permission: PermissionName };
-export type AdmissionConstraintHasUserLevel = { type: "has-user-level", level: string };
-
-export type AdmissionPreference = AdmissionPreferenceUserLevel;
-export type AdmissionPreferenceUserLevel = { type: 'user-level', level: string };
-
+export type AdmissionConstraintHasPermission = { type: "has-permission"; permission: PermissionName };
+export type AdmissionConstraintHasClass = { type: "has-class"; id: string; displayName: string };
+
+export namespace AdmissionConstraint {
+    export function is(o: any): o is AdmissionConstraint {
+        return !!o && "type" in o;
+    }
+    export function isHasPermissionConstraint(o: any): o is AdmissionConstraintHasPermission {
+        return is(o) && o.type === "has-permission";
+    }
+    export function hasPermission(ac: AdmissionConstraint, permission: PermissionName): boolean {
+        return isHasPermissionConstraint(ac) && ac.permission === permission;
+    }
+}
 
 export const WorkspaceClusterDB = Symbol("WorkspaceClusterDB");
 export interface WorkspaceClusterDB {
@@ -77,20 +90,21 @@ export interface WorkspaceClusterDB {
      * Deletes the cluster identified by this name, if any.
      * @param name
      */
-    deleteByName(name: string): Promise<void>;
+    deleteByName(name: string, applicationCluster: string): Promise<void>;
 
     /**
      * Finds a WorkspaceCluster with the given name. If there is none, `undefined` is returned.
      * @param name
      */
-    findByName(name: string): Promise<WorkspaceCluster | undefined>;
+    findByName(name: string, applicationCluster: string): Promise<WorkspaceCluster | undefined>;
 
     /**
      * Lists all WorkspaceClusterWoTls for which the given predicate is true (does not return TLS for size/speed concerns)
      * @param predicate
      */
-    findFiltered(predicate: DeepPartial<WorkspaceClusterFilter>): Promise<WorkspaceClusterWoTLS[]>;
+    findFiltered(predicate: WorkspaceClusterFilter): Promise<WorkspaceClusterWoTLS[]>;
 }
-export interface WorkspaceClusterFilter extends Pick<WorkspaceCluster, "state" | "govern" | "url"> {
-    minScore: number;
-}
+
+export type WorkspaceClusterFilter = Pick<WorkspaceCluster, "applicationCluster"> &
+    DeepPartial<Pick<WorkspaceCluster, "name" | "state" | "govern" | "url">> &
+    Partial<{ minScore: number }>;