BREAKING CHANGE(DockerHost): Refactor public API to DockerHost facade; introduce DockerResource base; make resource static methods internal; support flexible descriptors and stream compatibility

ts/classes.host.ts

@@ -1,8 +1,10 @@
 import * as plugins from './plugins.js';
 import * as paths from './paths.js';
+import * as interfaces from './interfaces/index.js';
 import { DockerContainer } from './classes.container.js';
 import { DockerNetwork } from './classes.network.js';
 import { DockerService } from './classes.service.js';
+import { DockerSecret } from './classes.secret.js';
 import { logger } from './logger.js';
 import { DockerImageStore } from './classes.imagestore.js';
 import { DockerImage } from './classes.image.js';
@@ -26,7 +28,7 @@ export class DockerHost {
    */
   public socketPath: string;
   private registryToken: string = '';
-  public imageStore: DockerImageStore;
+  private imageStore: DockerImageStore; // Now private - use storeImage/retrieveImage instead
   public smartBucket: plugins.smartbucket.SmartBucket;
 
   /**
@@ -123,70 +125,190 @@ export class DockerHost {
   }
 
   // ==============
-  // NETWORKS
+  // NETWORKS - Public Factory API
   // ==============
+
   /**
-   * gets all networks
+   * Gets all networks
    */
   public async getNetworks() {
-    return await DockerNetwork.getNetworks(this);
+    return await DockerNetwork._list(this);
   }
 
   /**
-   * create a network
-   */
-  public async createNetwork(
-    optionsArg: Parameters<typeof DockerNetwork.createNetwork>[1],
-  ) {
-    return await DockerNetwork.createNetwork(this, optionsArg);
-  }
-
-  /**
-   * get a network by name
+   * Gets a network by name
    */
   public async getNetworkByName(networkNameArg: string) {
-    return await DockerNetwork.getNetworkByName(this, networkNameArg);
+    return await DockerNetwork._fromName(this, networkNameArg);
+  }
+
+  /**
+   * Creates a network
+   */
+  public async createNetwork(
+    descriptor: interfaces.INetworkCreationDescriptor,
+  ) {
+    return await DockerNetwork._create(this, descriptor);
   }
 
   // ==============
-  // CONTAINERS
+  // CONTAINERS - Public Factory API
   // ==============
+
   /**
-   * gets all containers
+   * Gets all containers
    */
   public async getContainers() {
-    const containerArray = await DockerContainer.getContainers(this);
-    return containerArray;
+    return await DockerContainer._list(this);
+  }
+
+  /**
+   * Gets a container by ID
+   */
+  public async getContainerById(containerId: string) {
+    return await DockerContainer._fromId(this, containerId);
+  }
+
+  /**
+   * Creates a container
+   */
+  public async createContainer(
+    descriptor: interfaces.IContainerCreationDescriptor,
+  ) {
+    return await DockerContainer._create(this, descriptor);
   }
 
   // ==============
-  // SERVICES
+  // SERVICES - Public Factory API
   // ==============
 
   /**
-   * gets all services
+   * Gets all services
    */
   public async getServices() {
-    const serviceArray = await DockerService.getServices(this);
-    return serviceArray;
+    return await DockerService._list(this);
+  }
+
+  /**
+   * Gets a service by name
+   */
+  public async getServiceByName(serviceName: string) {
+    return await DockerService._fromName(this, serviceName);
+  }
+
+  /**
+   * Creates a service
+   */
+  public async createService(
+    descriptor: interfaces.IServiceCreationDescriptor,
+  ) {
+    return await DockerService._create(this, descriptor);
   }
 
   // ==============
-  // IMAGES
+  // IMAGES - Public Factory API
   // ==============
 
   /**
-   * get all images
+   * Gets all images
    */
   public async getImages() {
-    return await DockerImage.getImages(this);
+    return await DockerImage._list(this);
   }
 
   /**
-   * get an image by name
+   * Gets an image by name
    */
   public async getImageByName(imageNameArg: string) {
-    return await DockerImage.getImageByName(this, imageNameArg);
+    return await DockerImage._fromName(this, imageNameArg);
+  }
+
+  /**
+   * Creates an image from a registry
+   */
+  public async createImageFromRegistry(
+    descriptor: interfaces.IImageCreationDescriptor,
+  ) {
+    return await DockerImage._createFromRegistry(this, {
+      creationObject: descriptor,
+    });
+  }
+
+  /**
+   * Creates an image from a tar stream
+   */
+  public async createImageFromTarStream(
+    tarStream: plugins.smartstream.stream.Readable,
+    descriptor: interfaces.IImageCreationDescriptor,
+  ) {
+    return await DockerImage._createFromTarStream(this, {
+      creationObject: descriptor,
+      tarStream: tarStream,
+    });
+  }
+
+  /**
+   * Builds an image from a Dockerfile
+   */
+  public async buildImage(imageTag: string) {
+    return await DockerImage._build(this, imageTag);
+  }
+
+  // ==============
+  // SECRETS - Public Factory API
+  // ==============
+
+  /**
+   * Gets all secrets
+   */
+  public async getSecrets() {
+    return await DockerSecret._list(this);
+  }
+
+  /**
+   * Gets a secret by name
+   */
+  public async getSecretByName(secretName: string) {
+    return await DockerSecret._fromName(this, secretName);
+  }
+
+  /**
+   * Gets a secret by ID
+   */
+  public async getSecretById(secretId: string) {
+    return await DockerSecret._fromId(this, secretId);
+  }
+
+  /**
+   * Creates a secret
+   */
+  public async createSecret(
+    descriptor: interfaces.ISecretCreationDescriptor,
+  ) {
+    return await DockerSecret._create(this, descriptor);
+  }
+
+  // ==============
+  // IMAGE STORE - Public API
+  // ==============
+
+  /**
+   * Stores an image in the local image store
+   */
+  public async storeImage(
+    imageName: string,
+    tarStream: plugins.smartstream.stream.Readable,
+  ): Promise<void> {
+    return await this.imageStore.storeImage(imageName, tarStream);
+  }
+
+  /**
+   * Retrieves an image from the local image store
+   */
+  public async retrieveImage(
+    imageName: string,
+  ): Promise<plugins.smartstream.stream.Readable> {
+    return await this.imageStore.getImage(imageName);
   }
 
   /**
@@ -330,6 +452,7 @@ export class DockerHost {
     methodArg: string,
     routeArg: string,
     readStream?: plugins.smartstream.stream.Readable,
+    jsonData?: any,
   ) {
     const requestUrl = `${this.socketPath}${routeArg}`;
 
@@ -342,6 +465,11 @@ export class DockerHost {
       .timeout(30000)
       .options({ keepAlive: false, autoDrain: true }); // Disable auto-drain for streaming
 
+    // If we have JSON data, add it to the request
+    if (jsonData && Object.keys(jsonData).length > 0) {
+      smartRequest.json(jsonData);
+    }
+
     // If we have a readStream, use the new stream method with logging
     if (readStream) {
       let counter = 0;