cloudly/ts/manager.image/classes.imagemanager.ts

import type { Cloudly } from '../classes.cloudly.js';
import * as plugins from '../plugins.js';

import { Image } from './classes.image.js';

export class ImageManager {
  cloudlyRef: Cloudly;
  public typedrouter = new plugins.typedrequest.TypedRouter();
  public smartbucketInstance: plugins.smartbucket.SmartBucket;
  
  get db() {
    return this.cloudlyRef.mongodbConnector.smartdataDb;
  }

  public CImage = plugins.smartdata.setDefaultManagerForDoc(this, Image);


  constructor(cloudlyRefArg: Cloudly) {
    this.cloudlyRef = cloudlyRefArg;

    this.cloudlyRef.typedrouter.addTypedRouter(this.typedrouter);

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.image.IRequest_CreateImage>(
        'createImage',
        async (reqArg, toolsArg) => {
          await toolsArg.passGuards([this.cloudlyRef.authManager.adminJwtGuard], reqArg);
          const image = await this.CImage.create({
            name: reqArg.name,
            description: reqArg.description,
            versions: [],
          });
          return {
            image: await image.createSavableObject(),
          };
        }
      )
    )

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.image.IRequest_DeleteImage>(
        'deleteImage',
        async (reqArg, toolsArg) => {
          await toolsArg.passGuards([this.cloudlyRef.authManager.adminJwtGuard], reqArg);
          const image = await this.CImage.getInstance({
            id: reqArg.imageId,
          });
          await image.delete();
          return {};
        }
      )
    );

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.image.IRequest_GetAllImages>(
        'getAllImages',
        async (requestArg, toolsArg) => {
          await toolsArg.passGuards([this.cloudlyRef.authManager.adminJwtGuard], requestArg);
          const images = await this.CImage.getInstances({});
          return {
            images: await Promise.all(
              images.map((image) => {
                return image.createSavableObject();
              })
            ),
          };
        }
      )
    );

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.image.IRequest_PushImageVersion>(
        'pushImageVersion',
        async (reqArg) => {
          const pushStream = reqArg.imageStream;
          return {};
        }
      )
    );

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.image.IRequest_PullImageVersion>(
        'pullImageVersion',
        async (reqArg) => {
          const image = await this.CImage.getInstance({
            data: {
              name: reqArg.name,
            },
          });
          const imageVersion = null;
          const imageVirtualStream = new plugins.typedrequest.VirtualStream();
          return {
            imageStream: imageVirtualStream,
          };
        }
      )
    );
  }

  public async start() {
    const s3Descriptor: plugins.tsclass.storage.IS3Descriptor =
      await this.cloudlyRef.config.appData.waitForAndGetKey('s3Descriptor');
    console.log(this.cloudlyRef.config.data.s3Descriptor);
    this.smartbucketInstance = new plugins.smartbucket.SmartBucket(
      this.cloudlyRef.config.data.s3Descriptor
    );
    const bucket = await this.smartbucketInstance.getBucketByName('cloudly-test');
    await bucket.fastPut({ path: 'test/test.txt', contents: 'hello' });
  }

  public async createImage(nameArg: string) {
    const newImage = await this.CImage.create({
      name: nameArg,
    });
  }
}