1.0.6

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartexpose",
-  "version": "1.0.3",
+  "version": "1.0.6",
   "private": false,
   "description": "a package to expose things to the internet",
   "main": "dist_ts/index.js",

test/test.ts

@@ -9,17 +9,17 @@ import * as smartexpose from '../ts/index.js'
 let testSmartexpose: smartexpose.SmartExpose;
 
 tap.test('should create a valid instance of smartexpose using Webdav', async () => {
-  testSmartexpose = await smartexpose.SmartExpose.createWithWebdav({
+  testSmartexpose = new smartexpose.SmartExpose({
+    webdav: {
       webdavCredentials: {
         serverUrl: await testQenv.getEnvVarOnDemand('WEBDAV_SERVER_URL'),
         password: await testQenv.getEnvVarOnDemand('WEBDAV_SERVER_TOKEN'),
       },
       webdavSubPath: await testQenv.getEnvVarOnDemand('WEBDAV_SUB_PATH'),
-    exposeOptions: {
+    },
     deleteAfterMillis: 30000,
     privateUrl: true,
     exposedBaseUrl: await testQenv.getEnvVarOnDemand('EXPOSED_BASE_URL'),
-    }
   });
   await testSmartexpose.start();
   expect(testSmartexpose).toBeInstanceOf(smartexpose.SmartExpose);

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartexpose',
-  version: '1.0.3',
+  version: '1.0.6',
   description: 'a package to expose things to the internet'
 }

ts/classes.exposeprovider.ts

@@ -28,6 +28,16 @@ export abstract class ExposeProvider {
     status: 'created' | 'updated';
   }>;
 
+  public abstract exposeFileArray(optionsArg: {
+    smartFiles: plugins.smartfile.SmartFile[],
+    deleteAfterMillis?: number,
+    privateUrl?: boolean,
+  }): Promise<{
+    url: string;
+    id: string;
+    status: 'created' | 'updated';
+  }[]>;
+
   public abstract start(): Promise<void>;
 
   public abstract stop(): Promise<void>;

ts/classes.exposeprovider.webdav.ts

@@ -12,8 +12,9 @@ export class WebDavExposeProvider extends ExposeProvider {
   public webdavClient: plugins.smartwebdav.WebdavClient;
   public options: IWebdavExposeProviderOptions;
 
-  constructor(optionsArg: IWebdavExposeProviderOptions) {
+  constructor(smartexposeRefArg: SmartExpose, optionsArg: IWebdavExposeProviderOptions) {
     super();
+    this.smartExposeRef = smartexposeRefArg;
     this.options = optionsArg;
   }
 
@@ -38,39 +39,50 @@ export class WebDavExposeProvider extends ExposeProvider {
     this.webdavClient = new plugins.smartwebdav.WebdavClient(this.options.webdavCredentials);
     await this.ensureBaseDir();
     await this.houseKeeping();
-    this.smartExposeRef.taskmanager.addAndScheduleTask(new plugins.taskbuffer.Task({
+    this.smartExposeRef.taskmanager.addAndScheduleTask(
+      new plugins.taskbuffer.Task({
         name: 'webdavHousekeeping',
         taskFunction: async () => {
           await this.houseKeeping();
         },
-    }), '0 * * * * *')
+      }),
+      '0 * * * * *'
+    );
   }
 
   public async stop(): Promise<void> {
     // Nothing to do here
   }
 
-  public async exposeFile(optionsArg: {
-    smartFile: plugins.smartfile.SmartFile;
-    deleteAfterMillis?: number;
-    privateUrl?: boolean;
-  }): Promise<{ url: string; id: string; status: 'created' | 'updated' }> {
+  public async exposeFile(
+    optionsArg: Parameters<ExposeProvider['exposeFile']>[0]
+  ): Promise<{ url: string; id: string; status: 'created' | 'updated' }> {
     await this.ensureBaseDir();
     const fileId = plugins.smartunique.shortId(30);
-    console.log(`Expsing file under id: ${fileId}. (${
-      plugins.smartformat.prettyBytes(optionsArg.smartFile.contents.length)
-    })`);
+    console.log(
+      `Expsing file under id: ${fileId}. (${plugins.smartformat.prettyBytes(
+        optionsArg.smartFile.contents.length
+      )})`
+    );
     const webdavFilePath = await this.getFilePathById(fileId);
-    const fileToUpload = await plugins.smartfile.SmartFile.fromBuffer(webdavFilePath, optionsArg.smartFile.contents);
+    const fileToUpload = await plugins.smartfile.SmartFile.fromBuffer(
+      webdavFilePath,
+      optionsArg.smartFile.contents
+    );
     await this.webdavClient.uploadSmartFileArray([fileToUpload]);
     console.log(`checking file presence: ${webdavFilePath}`);
     const existsOnWebdav = await this.webdavClient.wdClient.exists(webdavFilePath);
-    const publicUrl = plugins.smartpath.join(this.smartExposeRef.options.exposedBaseUrl, webdavFilePath);
-    console.log(`cehcking for file at ${publicUrl}`)
+    const publicUrl = plugins.smartpath.join(
+      this.smartExposeRef.options.exposedBaseUrl,
+      webdavFilePath
+    );
+    console.log(`cehcking for file at ${publicUrl}`);
     const response = await plugins.smartrequest.getBinary(publicUrl);
     plugins.smartexpect.expect(response.body).toEqual(fileToUpload.contents);
     if (optionsArg.deleteAfterMillis) {
-      console.log(`Scheduling deletion of file with id: ${fileId} in ${optionsArg.deleteAfterMillis}ms...`);
+      console.log(
+        `Scheduling deletion of file with id: ${fileId} in ${optionsArg.deleteAfterMillis}ms...`
+      );
       plugins.smartdelay.delayFor(optionsArg.deleteAfterMillis).then(() => {
         console.log(`Deleting file with id: ${fileId}...`);
         this.deleteFileById(fileId);
@@ -84,6 +96,20 @@ export class WebDavExposeProvider extends ExposeProvider {
     };
   }
 
+  public async exposeFileArray(optionsArg: Parameters<ExposeProvider['exposeFileArray']>[0]) {
+    const returnArray = [];
+    for (const smartFile of optionsArg.smartFiles) {
+      returnArray.push(
+        await this.exposeFile({
+          smartFile,
+          deleteAfterMillis: optionsArg.deleteAfterMillis,
+          privateUrl: optionsArg.privateUrl,
+        })
+      );
+    }
+    return returnArray;
+  }
+
   public async wipeAll(): Promise<{ id: string; status: 'deleted' | 'failed' | 'notfound' }[]> {
     const directoryContents = await this.webdavClient.listDirectory(this.options.webdavSubPath);
     await this.webdavClient.ensureEmptyDirectory(this.options.webdavSubPath);

ts/classes.smartexpose.ts

@@ -6,36 +6,30 @@ export interface ISmartExposeOptions {
   deleteAfterMillis?: number,
   privateUrl?: boolean,
   exposedBaseUrl: string,
+  webdav?: {
+    webdavCredentials: plugins.smartwebdav.IWebdavClientOptions,
+    webdavSubPath: string,
+  }
 }
 
 export class SmartExpose {
-  // STATIC
-  public static createWithWebdav(optionsArg: {
-    webdavCredentials: plugins.smartwebdav.IWebdavClientOptions,
-    webdavSubPath: string,
-    exposeOptions: ISmartExposeOptions,
-  }) {
-    const provider = new WebDavExposeProvider({
-      webdavCredentials: optionsArg.webdavCredentials,
-      webdavSubPath: optionsArg.webdavSubPath,
-    });
-    const smartexposeInstance = new SmartExpose(provider, optionsArg.exposeOptions);
-    provider.smartExposeRef = smartexposeInstance;
-    return smartexposeInstance;
-  }
-
   // INSTANCE
   public taskmanager: plugins.taskbuffer.TaskManager;
   public provider: ExposeProvider;
   public options: ISmartExposeOptions;
 
-  constructor(provider: ExposeProvider, optionsArg: ISmartExposeOptions) {
-    this.provider = provider;
+  constructor(optionsArg: ISmartExposeOptions) {
     this.options = optionsArg;
   }
 
   public async start() {
     this.taskmanager = new plugins.taskbuffer.TaskManager();
+    if (this.options.webdav) {
+      this.provider = new WebDavExposeProvider(this, {
+        webdavCredentials: this.options.webdav.webdavCredentials,
+        webdavSubPath: this.options.webdav.webdavSubPath,
+      });
+    }
     await this.provider.start();
     this.taskmanager.start();
   }
@@ -48,4 +42,8 @@ export class SmartExpose {
   public async exposeFile(optionsArg: Parameters<ExposeProvider['exposeFile']>[0]) {
     return this.provider.exposeFile(optionsArg);
   }
+
+  public async exposeFileArray(optionsArg: Parameters<ExposeProvider['exposeFileArray']>[0]) {
+    return this.provider.exposeFileArray(optionsArg);
+  }
 }