Wrapper for new Secure File remake

src/index.ts

@@ -0,0 +1,223 @@
+import Observable from "./observable";
+import Lock from "./lock";
+
+export interface IFileVersion {
+   version: string;
+   time: Date;
+   preview: string;
+   deleted: boolean;
+}
+
+export interface IFile {
+   _id: string;
+   type: string;
+   name: string;
+   folder: string;
+   deleted: boolean;
+   active: IFileVersion;
+   versions: IFileVersion[];
+   user: string;
+   application: string;
+}
+
+export interface IHistory {
+   file: IFile;
+   history: IFileVersion[];
+}
+
+
+export class NoConnection extends Error {
+   type: string;
+   constructor() {
+      super("No connection");
+      this.type = "noconnection"
+   }
+}
+
+export class Unauthorized extends Error {
+   type: string;
+   constructor() {
+      super("Not authorized");
+      this.type = "unauthorized"
+   }
+}
+
+export class NoPermission extends Error {
+   type: string;
+   constructor() {
+      super("No permission");
+      this.type = "nopermission"
+   }
+}
+
+export class NotFound extends Error {
+   type: string;
+   constructor() {
+      super("Not found");
+      this.type = "notfound"
+   }
+}
+
+export class BadRequest extends Error {
+   type: string;
+   constructor() {
+      super("Bad request");
+      this.type = "badrequest"
+   }
+}
+
+import * as fetch from "isomorphic-fetch";
+
+function statusParser(res: Response) {
+   if (res.status !== 200) {
+      switch (res.status) {
+         case 400:
+            throw new BadRequest();
+         case 404:
+            throw new NotFound();
+         case 403:
+            throw new NoPermission();
+         case 401:
+            throw new Unauthorized();
+         default:
+            throw new Error(res.statusText);
+      }
+   }
+}
+
+export default class SecureFileWrapper {
+   private _jwtObservableServer: Observable<(jwt: string) => void> = new Observable();
+   jwtObservable = this._jwtObservableServer.getPublicApi();
+
+   jwt: string;
+
+   auth_lock = new Lock();
+
+   constructor(private server: string) {
+      if (this.server.endsWith("/")) {
+         this.server += "api/v1";
+      } else {
+         this.server += "/api/v1";
+      }
+   }
+
+   public async getJWT() {
+      if (!this.auth_lock.locked) {
+         let lock = await this.auth_lock.getLock();
+         this._jwtObservableServer.send((jwt: string) => {
+            this.jwt = jwt;
+            lock.release();
+         });
+      }
+
+      await this.auth_lock.getLock().then(lock => lock.release())
+   }
+
+   public async makeRequest(endpoint: string, method: "POST" | "GET" | "PUT" | "DELETE", query: any, body?: ArrayBuffer | ArrayBufferView, second = false) {
+      if (!this.jwt || this.jwt === undefined) {
+         await this.getJWT();
+      }
+
+      query.jwt = this.jwt;
+      let query_str = "?";
+      let first = true;
+      for (let key in query) {
+         if (!first) query_str += "&";
+         query_str += encodeURIComponent(key) + "=" + encodeURIComponent(query[key]);
+         first = false;
+      }
+      var headers = {
+         "pragme": "no-cache",
+         "cache-control": "no-cache"
+      };
+
+      let body_n;
+      if (body) {
+         headers["Content-Type"] = "application/octet-stream"
+         body_n = Buffer ? Buffer.from(body instanceof ArrayBuffer ? body : body.buffer) : body;
+      }
+      try {
+         let res = await fetch(this.server + endpoint + query_str, { method, body: body_n, headers });
+         if (res.status === 401 && !second) {
+            await this.getJWT();
+            return this.makeRequest(endpoint, method, query, body, true);
+         } else {
+            statusParser(res);
+            return res;
+         }
+      } catch (err) {
+         if (err instanceof TypeError || err.errno === "ECONNREFUSED")
+            throw new NoConnection();
+         throw err;
+      }
+   }
+
+   // async test(jwt): Promise<{ user: string, test: true }> {
+   //    let res = await this.makeRequest("/test", "GET", {}, undefined, this.jwt_enabled);
+   //    statusParser(res);
+   //    return await res.json();
+   // }
+
+   async list(folder?: string): Promise<IFile[]> {
+      let query: any = {}
+      if (folder) query.folder = folder;
+      let res = await this.makeRequest("/file", "GET", query);
+      let d = await res.json();
+      return d.files;
+   }
+
+   async create(name: string, data: ArrayBuffer | ArrayBufferView, type: "text" | "binary", folder?: string, preview?: string): Promise<IFile> {
+      let params: any = { type: type, name: name };
+      if (preview) {
+         params.preview = preview;
+      }
+      if (folder) {
+         params.folder = folder;
+      }
+
+      let res = await this.makeRequest("/file", "POST", params, data);
+      return (await res.json()).file;
+   }
+
+   async get(id: string, version?: string): Promise<ArrayBuffer> {
+      let res: Response;
+      if (typeof version === "string") {
+         res = await this.makeRequest(`/file/${id}/history/${version}`, "GET", {});
+      } else {
+         res = await this.makeRequest("/file/" + id, "GET", {});
+      }
+
+      if (res.arrayBuffer) {
+         return res.arrayBuffer()
+      } else {
+         let blob: Buffer = await (<any>res).buffer()
+         // console.log(blob.length);
+         return Uint8Array.from(blob).buffer;
+      }
+   }
+
+   async update(id: string, data: ArrayBuffer | ArrayBufferView, preview?: string): Promise<IFile> {
+      let put: any = {};
+      if (preview) put.preview = preview;
+      let res = await this.makeRequest("/file/" + id, "PUT", put, data);
+
+      let json = await res.json()
+      return json.file;
+   }
+
+   async delete(id: string): Promise<boolean> {
+      let res = await this.makeRequest("/file/" + id, "DELETE", {});
+
+      return res.json();
+   }
+
+   async history(id: string): Promise<IHistory> {
+      let res = await this.makeRequest(`/file/${id}/history`, "GET", {});
+      statusParser(res);
+      return res.json();
+   }
+
+   async restore(id: string, version: string) {
+      await this.makeRequest(`/file/${id}/history/${version}/restore`, "PUT", {});
+   }
+}

src/lock.ts

@@ -0,0 +1,36 @@
+export type Release = { release: () => void };
+export default class Lock {
+   private _locked: boolean = false;
+   get locked() {
+      return this._locked;
+   }
+   private toCome: (() => void)[] = [];
+
+   constructor() {
+      this.release = this.release.bind(this);
+   }
+
+   async getLock(): Promise<Release> {
+      if (!this._locked) return { release: this.lock() };
+      else {
+         return new Promise<Release>((resolve) => {
+            this.toCome.push(() => {
+               resolve({ release: this.lock() });
+            })
+         })
+      }
+   }
+
+   private lock() {
+      this._locked = true;
+      return this.release;
+   }
+
+   private async release() {
+      if (this.toCome.length > 0) {
+         this.toCome.shift()();
+      } else {
+         this._locked = false;
+      }
+   }
+}

src/observable.ts

@@ -0,0 +1,38 @@
+export type ObserverCallback<T> = (data: T) => void;
+
+export default class Observable<T = any> {
+   private subscriber: ObserverCallback<T[]>[] = [];
+   private events: T[] = [];
+   private timeout = undefined;
+
+   constructor(private collect: boolean = true, private collect_intervall: number = 100) { }
+
+   getPublicApi() {
+      return {
+         subscribe: (callback: ObserverCallback<T[]>) => {
+            if (this.subscriber.indexOf(callback) < 0)
+               this.subscriber.push(callback)
+         },
+         unsubscribe: (callback: ObserverCallback<T[]>) => {
+            let idx = this.subscriber.indexOf(callback);
+            if (idx >= 0) {
+               this.subscriber.splice(idx, 1);
+            }
+         }
+      }
+   }
+
+   send(data: T) {
+      if (!this.collect)
+         this.subscriber.forEach(e => e([data]));
+      else {
+         this.events.push(data);
+         if (!this.timeout) {
+            this.timeout = setTimeout(() => {
+               this.subscriber.forEach(e => e(this.events));
+               this.timeout = 0;
+            }, this.collect_intervall);
+         }
+      }
+   }
+}

src/test.ts

@@ -0,0 +1,130 @@
+import SecureFile, { NotFound } from "./index";
+
+import { TextEncoder, TextDecoder } from "util";
+
+const testname = "ouiavgbsop687463743"
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const testdata = encoder.encode("Ich bin ein Test");
+const newTestData = encoder.encode("neue test daten");
+const testprev = "Ich bin...";
+
+const testfolder = "iabos";
+let ftestid;
+
+import { expect } from "chai"
+
+function test(sf: SecureFile) {
+   let testid: string;
+   let testver: string;
+   let testver2: string;
+
+   it("create", async () => {
+      let res = await sf.create(testname, testdata, "text", undefined, testprev)
+      expect(res, "Res isnnot set").to.exist;
+      expect(res._id, "Res has no _id").to.exist;
+      testid = res._id;
+      testver = res.active.version;
+   })
+
+   it("get", async () => {
+      let res = await sf.get(testid);
+      expect(res, "No data returned").to.exist;
+      expect(decoder.decode(res), "Returned data not equal to stored").to.be.equal(decoder.decode(testdata));
+   })
+
+   it("get - fail", async () => {
+      const inverr = new Error("Should have failed!");
+      try {
+         await sf.get(testid + "asod");
+         throw inverr
+      } catch (err) {
+         if (err !== inverr) {
+            expect(err).to.be.instanceOf(NotFound);
+         }
+      }
+   })
+
+   it("list", async () => {
+      let res = await sf.list();
+      expect(Array.isArray(res), "Is not from type Array").to.be.true;
+      expect(res.length, "No elements returned").to.greaterThan(0);
+      let found = !!res.find(e => e._id === testid);
+      expect(found, "Element not in List").to.be.true;
+   })
+
+   it("update", async () => {
+      let res = await sf.update(testid, newTestData, undefined);
+      expect(res, "No data returned").to.exist;
+      expect(res._id, "_id missing").to.exist;
+      expect(res.active.version, "No new version was created").to.not.equal(testver);
+      testver2 = res.active.version;
+      let res2 = await sf.get(testid);
+      expect(decoder.decode(res2), "Fetched data not updated").to.be.equal(decoder.decode(newTestData));
+   })
+
+   it("history", async () => {
+      let his = await sf.history(testid);
+      expect(his, "no data returned").to.exist;
+      expect(his.file, "file not set").to.exist;
+      expect(his.history, "history not set").to.exist;
+      expect(his.history.length, `Not expected history length. Expected 1 got ${his.history.length}`).to.be.equal(1);
+
+      expect(his.history[0].version, "Wrong version on history").to.be.equal(testver);
+      expect(his.file.active.version, "Wrong version on file").to.be.equal(testver2);
+   });
+
+   it("history get old", async () => {
+      let arch = await sf.get(testid, testver);
+      expect(decoder.decode(arch), "Old version has wrong data").to.be.equal(decoder.decode(testdata));
+   })
+
+   it("history restore", async () => {
+      await sf.restore(testid, testver);
+
+      let res = await sf.get(testid);
+      expect(res, "No data returned").to.exist;
+      expect(decoder.decode(res), "Returned data not equal to stored").to.be.equal(decoder.decode(testdata));
+   })
+
+   it("delete", async () => {
+      let res = await sf.delete(testid);
+      expect(res, "Res not set").to.exist;
+   })
+
+   describe("folder", () => {
+      it("create", async () => {
+         let res = await sf.create(testname, testdata, "text", testfolder, testprev)
+         expect(res, "Res not set").to.exist;
+         expect(res._id, "No _id field").to.exist;
+         ftestid = res._id;
+         testver = res.active.version;
+      })
+
+      it("list", async () => {
+         let res = await sf.list(testfolder);
+         expect(Array.isArray(res), "Is from type Array").to.be.true;
+         expect(res.length, "Do elements exist?").to.be.greaterThan(0);
+         let found = false;
+         res.forEach(e => {
+            if (e._id === ftestid) {
+               found = true;
+            }
+         })
+         expect(found, "Element is not in List").to.exist;
+      })
+
+      it("delete", async () => {
+         let res = await sf.delete(ftestid);
+         expect(res, "Res not set").to.exist;
+      });
+   })
+}
+
+describe("SecureFile Tests", function () {
+   let sf = new SecureFile("http://localhost:3004");
+   sf.jwtObservable.subscribe((callback) => {
+      callback[0]("TESTJWT");
+   })
+   test(sf)
+})