Merge branch 'remake' of OpenServer/OSSecureFileWrapper into master

.gitignore

@@ -1,4 +1,4 @@
-node_modules/
+node_modules/
-yarn.lock
+yarn.lock
-private.pem
+private.pem
-lib/
+lib/

.npmignore

@@ -1,3 +1,3 @@
-tsconfig.json
+tsconfig.json
-node_modules/
+src/
-.vscode/
+node_modules/

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+   "cSpell.enabled": false
+}

package.json

@@ -1,29 +1,27 @@
-{
+{
-   "name": "@hibas123/secure-file-wrapper",
+   "name": "secure-file-wrapper",
-   "version": "2.3.3",
+   "version": "2.0.0",
-   "main": "lib/index.js",
+   "main": "lib/index.js",
-   "author": "Fabian Stamm <dev@fabianstamm.de>",
+   "author": "Fabian Stamm <dev@fabianstamm.de>",
-   "license": "MIT",
+   "license": "MIT",
-   "types": "lib/index.d.ts",
+   "types": "lib/index.d.ts",
-   "scripts": {
+   "scripts": {
-      "build": "tsc",
+      "build": "tsc",
-      "watch": "tsc --watch",
+      "watch": "tsc --watch",
-      "prepublishOnly": "tsc",
+      "prepublish": "tsc",
-      "test": "mocha lib/test.js"
+      "test": "mocha lib/test.js"
-   },
+   },
-   "dependencies": {
+   "dependencies": {
-      "@hibas123/utils": "^1.0.1",
+      "isomorphic-fetch": "^2.2.1"
-      "cross-fetch": "^3.0.1",
+   },
-      "uuid": "^3.3.2"
+   "devDependencies": {
-   },
+      "@types/chai": "^4.1.4",
-   "devDependencies": {
+      "@types/isomorphic-fetch": "^0.0.34",
-      "@types/chai": "^4.1.4",
+      "@types/mocha": "^5.2.2",
-      "@types/mocha": "^5.2.6",
+      "@types/node": "^10.12.18",
-      "@types/node": "^11.10.5",
+      "@types/node-fetch": "^2.1.4",
-      "@types/node-fetch": "^2.1.6",
+      "chai": "^4.1.2",
-      "@types/uuid": "^3.4.4",
+      "mocha": "^5.2.0",
-      "chai": "^4.1.2",
+      "typescript": "^3.2.2"
-      "mocha": "^6.0.2",
+   }
-      "typescript": "^3.3.3333"
-   }
 }

src/index.ts

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

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

tsconfig.json

@@ -1,17 +1,17 @@
-{
+{
-   "compilerOptions": {
+   "compilerOptions": {
-      /* Basic Options */
+      /* Basic Options */
-      "target": "es6", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'. */
+      "target": "es6", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'. */
-      "module": "commonjs", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
+      "module": "commonjs", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
-      "declaration": true, /* Generates corresponding '.d.ts' file. */
+      "declaration": true, /* Generates corresponding '.d.ts' file. */
-      "lib": [
+      "lib": [
-         "es6",
+         "es6",
-         "dom"
+         "dom"
-      ],
+      ],
-      "outDir": "./lib",
+      "outDir": "./lib",
-      "sourceMap": true
+      "sourceMap": true
-   },
+   },
-   "include": [
+   "include": [
-      "./src"
+      "./src"
-   ]
+   ]
 }