Using native fetch on supported browsers

.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
-src/
+node_modules/
-node_modules/
+.vscode/

.vscode/settings.json

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

package.json

@@ -1,27 +1,29 @@
-{
+{
-   "name": "secure-file-wrapper",
+   "name": "@hibas123/secure-file-wrapper",
-   "version": "2.0.0",
+   "version": "2.3.3",
-   "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",
-      "prepublish": "tsc",
+      "prepublishOnly": "tsc",
-      "test": "mocha lib/test.js"
+      "test": "mocha lib/test.js"
-   },
+   },
-   "dependencies": {
+   "dependencies": {
-      "isomorphic-fetch": "^2.2.1"
+      "@hibas123/utils": "^1.0.1",
-   },
+      "cross-fetch": "^3.0.1",
-   "devDependencies": {
+      "uuid": "^3.3.2"
-      "@types/chai": "^4.1.4",
+   },
-      "@types/isomorphic-fetch": "^0.0.34",
+   "devDependencies": {
-      "@types/mocha": "^5.2.2",
+      "@types/chai": "^4.1.4",
-      "@types/node": "^10.12.18",
+      "@types/mocha": "^5.2.6",
-      "@types/node-fetch": "^2.1.4",
+      "@types/node": "^11.10.5",
-      "chai": "^4.1.2",
+      "@types/node-fetch": "^2.1.6",
-      "mocha": "^5.2.0",
+      "@types/uuid": "^3.4.4",
-      "typescript": "^3.2.2"
+      "chai": "^4.1.2",
-   }
+      "mocha": "^6.0.2",
+      "typescript": "^3.3.3333"
+   }
 }

src/index.ts

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

@@ -1,36 +0,0 @@
-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

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