berget 2.2.6 → 2.2.8

package/src/services/cluster-service.ts

@@ -1,12 +1,12 @@
-import { createAuthenticatedClient } from '../client'
-import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
+import { createAuthenticatedClient } from '../client';
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure';
 
 export interface Cluster {
-  id: string
-  name: string
-  status: string
-  nodes: number
-  created: string
+  created: string;
+  id: string;
+  name: string;
+  nodes: number;
+  status: string;
 }
 
 /**
@@ -14,72 +14,69 @@ export interface Cluster {
  * Command group: clusters
  */
 export class ClusterService {
-  private static instance: ClusterService
-  private client = createAuthenticatedClient()
-
   // Command group name for this service
-  public static readonly COMMAND_GROUP = COMMAND_GROUPS.CLUSTERS
-
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.CLUSTERS;
   // Subcommands for this service
-  public static readonly COMMANDS = SUBCOMMANDS.CLUSTERS
+  public static readonly COMMANDS = SUBCOMMANDS.CLUSTERS;
+
+  private static instance: ClusterService;
+
+  private client = createAuthenticatedClient();
 
   private constructor() {}
 
   public static getInstance(): ClusterService {
     if (!ClusterService.instance) {
-      ClusterService.instance = new ClusterService()
+      ClusterService.instance = new ClusterService();
     }
-    return ClusterService.instance
+    return ClusterService.instance;
   }
 
   /**
-   * Get resource usage for a cluster
-   * Command: berget clusters get-usage
+   * Get detailed information about a cluster
+   * Command: berget clusters describe
    */
-  public async getUsage(clusterId: string): Promise<any> {
+  public async describe(clusterId: string): Promise<Cluster | null> {
     try {
-      const { data, error } = await this.client.GET(
-        '/v1/clusters/{clusterId}/usage',
-        {
-          params: { path: { clusterId } },
-        },
-      )
-      if (error) throw new Error(JSON.stringify(error))
-      return data
+      // This is a placeholder since the API doesn't have a specific endpoint
+      // In a real implementation, this would call a specific endpoint
+      const clusters = await this.list();
+      return clusters.find((cluster) => cluster.id === clusterId) || null;
     } catch (error) {
-      console.error('Failed to get cluster usage:', error)
-      throw error
+      console.error('Failed to describe cluster:', error);
+      throw error;
     }
   }
 
   /**
-   * List all clusters
-   * Command: berget clusters list
+   * Get resource usage for a cluster
+   * Command: berget clusters get-usage
    */
-  public async list(): Promise<Cluster[]> {
+  public async getUsage(clusterId: string): Promise<any> {
     try {
-      const { data, error } = await this.client.GET('/v1/clusters')
-      if (error) throw new Error(JSON.stringify(error))
-      return data?.data || []
+      const { data, error } = await this.client.GET('/v1/clusters/{clusterId}/usage', {
+        params: { path: { clusterId } },
+      });
+      if (error) throw new Error(JSON.stringify(error));
+      return data;
     } catch (error) {
-      console.error('Failed to list clusters:', error)
-      throw error
+      console.error('Failed to get cluster usage:', error);
+      throw error;
     }
   }
 
   /**
-   * Get detailed information about a cluster
-   * Command: berget clusters describe
+   * List all clusters
+   * Command: berget clusters list
    */
-  public async describe(clusterId: string): Promise<Cluster | null> {
+  public async list(): Promise<Cluster[]> {
     try {
-      // This is a placeholder since the API doesn't have a specific endpoint
-      // In a real implementation, this would call a specific endpoint
-      const clusters = await this.list()
-      return clusters.find((cluster) => cluster.id === clusterId) || null
+      const { data, error } = await this.client.GET('/v1/clusters');
+      if (error) throw new Error(JSON.stringify(error));
+      return data?.data || [];
     } catch (error) {
-      console.error('Failed to describe cluster:', error)
-      throw error
+      console.error('Failed to list clusters:', error);
+      throw error;
     }
   }
 }

package/src/services/collaborator-service.ts

@@ -1,10 +1,9 @@
-import { createAuthenticatedClient } from '../client'
-import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure';
 
 export interface Collaborator {
-  username: string
-  role: string
-  status: string
+  role: string;
+  status: string;
+  username: string;
 }
 
 /**
@@ -12,22 +11,21 @@ export interface Collaborator {
  * Command group: users
  */
 export class CollaboratorService {
-  private static instance: CollaboratorService
-  private client = createAuthenticatedClient()
-
   // Command group name for this service
-  public static readonly COMMAND_GROUP = COMMAND_GROUPS.USERS
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.USERS;
 
   // Subcommands for this service
-  public static readonly COMMANDS = SUBCOMMANDS.USERS
+  public static readonly COMMANDS = SUBCOMMANDS.USERS;
+
+  private static instance: CollaboratorService;
 
   private constructor() {}
 
   public static getInstance(): CollaboratorService {
     if (!CollaboratorService.instance) {
-      CollaboratorService.instance = new CollaboratorService()
+      CollaboratorService.instance = new CollaboratorService();
     }
-    return CollaboratorService.instance
+    return CollaboratorService.instance;
   }
 
   /**
@@ -35,11 +33,8 @@ export class CollaboratorService {
    * Command: berget users invite
    * This endpoint is not available in the API
    */
-  public async invite(
-    clusterId: string,
-    githubUsername: string,
-  ): Promise<Collaborator[]> {
-    throw new Error('This functionality is not available in the API')
+  public async invite(_clusterId: string, _githubUsername: string): Promise<Collaborator[]> {
+    throw new Error('This functionality is not available in the API');
   }
 
   /**
@@ -47,7 +42,7 @@ export class CollaboratorService {
    * Command: berget users list
    * This endpoint is not available in the API
    */
-  public async list(clusterId: string): Promise<Collaborator[]> {
-    throw new Error('This functionality is not available in the API')
+  public async list(_clusterId: string): Promise<Collaborator[]> {
+    throw new Error('This functionality is not available in the API');
   }
 }

package/src/services/flux-service.ts

@@ -1,16 +1,15 @@
-import { createAuthenticatedClient } from '../client'
-import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure';
 
-export interface FluxInstallOptions {
-  cluster: string
+export interface FluxBootstrapOptions {
+  owner?: string;
+  path?: string;
+  personal?: boolean;
+  provider: string;
+  repository?: string;
 }
 
-export interface FluxBootstrapOptions {
-  provider: string
-  owner?: string
-  repository?: string
-  path?: string
-  personal?: boolean
+export interface FluxInstallOptions {
+  cluster: string;
 }
 
 /**
@@ -18,39 +17,38 @@ export interface FluxBootstrapOptions {
  * Command group: flux
  */
 export class FluxService {
-  private static instance: FluxService
-  private client = createAuthenticatedClient()
-
   // Command group name for this service
-  public static readonly COMMAND_GROUP = COMMAND_GROUPS.FLUX
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.FLUX;
 
   // Subcommands for this service
-  public static readonly COMMANDS = SUBCOMMANDS.FLUX
+  public static readonly COMMANDS = SUBCOMMANDS.FLUX;
+
+  private static instance: FluxService;
 
   private constructor() {}
 
   public static getInstance(): FluxService {
     if (!FluxService.instance) {
-      FluxService.instance = new FluxService()
+      FluxService.instance = new FluxService();
     }
-    return FluxService.instance
+    return FluxService.instance;
   }
 
   /**
-   * Install Flux CD
-   * Command: berget flux install
+   * Bootstrap Flux CD
+   * Command: berget flux bootstrap
    * This endpoint is not available in the API
    */
-  public async install(options: FluxInstallOptions): Promise<boolean> {
-    throw new Error('This functionality is not available in the API')
+  public async bootstrap(_options: FluxBootstrapOptions): Promise<boolean> {
+    throw new Error('This functionality is not available in the API');
   }
 
   /**
-   * Bootstrap Flux CD
-   * Command: berget flux bootstrap
+   * Install Flux CD
+   * Command: berget flux install
    * This endpoint is not available in the API
    */
-  public async bootstrap(options: FluxBootstrapOptions): Promise<boolean> {
-    throw new Error('This functionality is not available in the API')
+  public async install(_options: FluxInstallOptions): Promise<boolean> {
+    throw new Error('This functionality is not available in the API');
   }
 }

package/src/services/helm-service.ts

@@ -1,16 +1,15 @@
-import { createAuthenticatedClient } from '../client'
-import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure';
 
-export interface HelmRepoAddOptions {
-  name: string
-  url: string
+export interface HelmInstallOptions {
+  chart: string;
+  name: string;
+  namespace?: string;
+  values?: Record<string, string>;
 }
 
-export interface HelmInstallOptions {
-  name: string
-  chart: string
-  namespace?: string
-  values?: Record<string, string>
+export interface HelmRepoAddOptions {
+  name: string;
+  url: string;
 }
 
 /**
@@ -18,22 +17,21 @@ export interface HelmInstallOptions {
  * Command group: helm
  */
 export class HelmService {
-  private static instance: HelmService
-  private client = createAuthenticatedClient()
-
   // Command group name for this service
-  public static readonly COMMAND_GROUP = COMMAND_GROUPS.HELM
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.HELM;
 
   // Subcommands for this service
-  public static readonly COMMANDS = SUBCOMMANDS.HELM
+  public static readonly COMMANDS = SUBCOMMANDS.HELM;
+
+  private static instance: HelmService;
 
   private constructor() {}
 
   public static getInstance(): HelmService {
     if (!HelmService.instance) {
-      HelmService.instance = new HelmService()
+      HelmService.instance = new HelmService();
     }
-    return HelmService.instance
+    return HelmService.instance;
   }
 
   /**
@@ -41,8 +39,8 @@ export class HelmService {
    * Command: berget helm add-repo
    * This endpoint is not available in the API
    */
-  public async addRepo(options: HelmRepoAddOptions): Promise<boolean> {
-    throw new Error('This functionality is not available in the API')
+  public async addRepo(_options: HelmRepoAddOptions): Promise<boolean> {
+    throw new Error('This functionality is not available in the API');
   }
 
   /**
@@ -50,7 +48,7 @@ export class HelmService {
    * Command: berget helm install
    * This endpoint is not available in the API
    */
-  public async install(options: HelmInstallOptions): Promise<any> {
-    throw new Error('This functionality is not available in the API')
+  public async install(_options: HelmInstallOptions): Promise<any> {
+    throw new Error('This functionality is not available in the API');
   }
 }

package/src/services/kubectl-service.ts

@@ -1,45 +1,43 @@
-import { createAuthenticatedClient } from '../client'
-import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure';
 
 /**
  * Service for managing Kubernetes resources
  * Command group: kubectl
  */
 export class KubectlService {
-  private static instance: KubectlService
-  private client = createAuthenticatedClient()
-
   // Command group name for this service
-  public static readonly COMMAND_GROUP = COMMAND_GROUPS.KUBECTL
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.KUBECTL;
 
   // Subcommands for this service
-  public static readonly COMMANDS = SUBCOMMANDS.KUBECTL
+  public static readonly COMMANDS = SUBCOMMANDS.KUBECTL;
+
+  private static instance: KubectlService;
 
   private constructor() {}
 
   public static getInstance(): KubectlService {
     if (!KubectlService.instance) {
-      KubectlService.instance = new KubectlService()
+      KubectlService.instance = new KubectlService();
     }
-    return KubectlService.instance
+    return KubectlService.instance;
   }
 
   /**
-   * Create a Kubernetes namespace
-   * Command: berget kubectl create-namespace
+   * Apply a Kubernetes configuration
+   * Command: berget kubectl apply
    * This endpoint is not available in the API
    */
-  public async createNamespace(name: string): Promise<boolean> {
-    throw new Error('This functionality is not available in the API')
+  public async apply(_filename: string): Promise<boolean> {
+    throw new Error('This functionality is not available in the API');
   }
 
   /**
-   * Apply a Kubernetes configuration
-   * Command: berget kubectl apply
+   * Create a Kubernetes namespace
+   * Command: berget kubectl create-namespace
    * This endpoint is not available in the API
    */
-  public async apply(filename: string): Promise<boolean> {
-    throw new Error('This functionality is not available in the API')
+  public async createNamespace(_name: string): Promise<boolean> {
+    throw new Error('This functionality is not available in the API');
   }
 
   /**
@@ -47,7 +45,7 @@ export class KubectlService {
    * Command: berget kubectl get
    * This endpoint is not available in the API
    */
-  public async get(resource: string, namespace?: string): Promise<any[]> {
-    throw new Error('This functionality is not available in the API')
+  public async get(_resource: string, _namespace?: string): Promise<any[]> {
+    throw new Error('This functionality is not available in the API');
   }
 }