tering-serieuze-sdk 1.0.0

package/.prettierrc

@@ -0,0 +1,2 @@
+tabWidth: 4
+printWidth: 120

package/README.md

@@ -0,0 +1 @@
+# Tering serieuze SDK

package/dist/index.mjs

@@ -0,0 +1,284 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/cache/abstractCache.ts
+import { get } from "stack-trace";
+var CacheLifetime = /* @__PURE__ */ ((CacheLifetime2) => {
+  CacheLifetime2[CacheLifetime2["Day"] = 86400] = "Day";
+  CacheLifetime2[CacheLifetime2["Week"] = 604800] = "Week";
+  return CacheLifetime2;
+})(CacheLifetime || {});
+var AbstractCache = class {
+  constructor(cacheName) {
+    this.cacheName = cacheName;
+  }
+  getCacheKey() {
+    const errorMessage = "Could not determine cache key. Please provide a key manually.";
+    const trace = get();
+    if (trace.length < 3) {
+      throw new Error(errorMessage);
+    }
+    const functionName = get()[2].getFunctionName();
+    if (!functionName) {
+      throw new Error(errorMessage);
+    }
+    return functionName;
+  }
+};
+
+// src/cache/cookieCache.ts
+var CookieCache = class extends AbstractCache {
+  cacheOrGet(callbackWhenEmpty, key, lifetime) {
+    return callbackWhenEmpty();
+  }
+  async get(key) {
+    return void 0;
+  }
+  set(key, value) {
+  }
+  remove(key) {
+  }
+  clear() {
+  }
+};
+
+// src/cache/filesystemCache.ts
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import path from "path";
+import os from "os";
+var FilesystemCache = class extends AbstractCache {
+  initialized = false;
+  state = {};
+  async cacheOrGet(callbackWhenEmpty, key, lifetime) {
+    key = key ?? this.getCacheKey();
+    const cachedValue = await this.get(key);
+    if (cachedValue) {
+      return cachedValue;
+    }
+    const result = await callbackWhenEmpty();
+    this.set(key, result, lifetime);
+    return result;
+  }
+  async get(key) {
+    if (!this.initialized) {
+      await this._initialize();
+    }
+    const expires = this.state[key]?.expiresAt;
+    if (Object.keys(this.state).includes(key) && (expires === void 0 || expires > Date.now())) {
+      return this.state[key].value;
+    }
+    return void 0;
+  }
+  set(key, value, lifetime) {
+    const expiresAt = lifetime ? Date.now() + lifetime : void 0;
+    const content = { value };
+    if (expiresAt) {
+      content.expiresAt = expiresAt;
+    }
+    this.state[key] = content;
+    this.writeState();
+  }
+  remove(key) {
+    delete this.state[key];
+    this.writeState();
+  }
+  clear() {
+    this.state = {};
+    unlinkSync(this.getFilePath());
+  }
+  getFilePath() {
+    return path.join(os.homedir(), ".tss", `${this.cacheName}.json`);
+  }
+  _initialize() {
+    this.initialized = true;
+    if (existsSync(this.getFilePath())) {
+      this.state = JSON.parse(readFileSync(this.getFilePath(), "utf8"));
+    }
+  }
+  writeState() {
+    if (!existsSync(path.dirname(this.getFilePath()))) {
+      mkdirSync(path.dirname(this.getFilePath()));
+    }
+    writeFileSync(this.getFilePath(), JSON.stringify(this.state));
+  }
+};
+
+// src/cache/nullCache.ts
+var NullCache = class extends AbstractCache {
+  cacheOrGet(callbackWhenEmpty, key, lifetime) {
+    return callbackWhenEmpty();
+  }
+  async get(key) {
+    return void 0;
+  }
+  set(key, value) {
+  }
+  remove(key) {
+  }
+  clear() {
+  }
+};
+
+// src/cache/onePasswordCache.ts
+import { promisify } from "util";
+import { exec } from "child_process";
+var asyncExec = promisify(exec);
+var OnePasswordCache = class extends AbstractCache {
+  cacheOrGet(callbackWhenEmpty, key, lifetime) {
+    throw new Error("Not implemented, use get() and set()");
+  }
+  async get(key) {
+    const { stdout, stderr } = await asyncExec(`op item get "${key}" --fields label=credential --format json`);
+    if (stderr) {
+      console.log(stderr);
+      throw new Error("ERROR");
+    }
+    return JSON.parse(stdout).value;
+  }
+  async set(key, value) {
+    let action = `op item edit '${key}' 'credential=${value}'`;
+    try {
+      const t = await this.get(key);
+    } catch (e) {
+      action = `op item create --category="API Credential" --title ${key} 'credential=${value}'`;
+    }
+    const { stdout, stderr } = await asyncExec(action);
+    if (stderr) {
+      console.log(stderr);
+      throw new Error("ERROR");
+    }
+  }
+  async remove(key) {
+    await asyncExec(`op item delete '${key}'`);
+  }
+  clear() {
+  }
+};
+
+// src/api/base.ts
+var BaseModule = class {
+  constructor(api, cache) {
+    this.api = api;
+    this.cache = cache;
+  }
+  getCache() {
+    return this.cache;
+  }
+  setCache(cache) {
+    this.cache = cache;
+  }
+};
+
+// src/api/auth.ts
+var _AuthModule = class extends BaseModule {
+  async getToken() {
+    return this.cache.get(_AuthModule.cacheKey);
+  }
+  async setToken(token) {
+    return this.cache.set(_AuthModule.cacheKey, token);
+  }
+  async removeToken() {
+    return this.cache.remove(_AuthModule.cacheKey);
+  }
+};
+var AuthModule = _AuthModule;
+__publicField(AuthModule, "cacheKey", "TSS-TOKEN");
+
+// src/api/jingle.ts
+var JingleModule = class extends BaseModule {
+  async getGrouped() {
+    return this.cache.cacheOrGet(() => {
+      return this.api.fetch("jingle/grouped");
+    });
+  }
+  async getAll() {
+    return this.cache.cacheOrGet(() => {
+      return this.api.fetch("jingle");
+    });
+  }
+  async play(folder, file) {
+    console.log(`Playing jingle ${folder}/${file}`);
+    return this.api.post("jingle/play", { folder, file });
+  }
+};
+
+// src/api/user.ts
+var UserModule = class extends BaseModule {
+  async get(userId) {
+    return this.cache.cacheOrGet(() => {
+      const userIdParam = userId ? `/${userId}` : "";
+      return this.api.fetch(`user${userIdParam}`);
+    });
+  }
+};
+
+// src/index.ts
+import {
+  BadRequestException,
+  ForbiddenException,
+  NotFoundException,
+  UnauthorizedException,
+  UnprocessableEntityException
+} from "@nestjs/common";
+var CacheType = /* @__PURE__ */ ((CacheType2) => {
+  CacheType2["jingle"] = "jingle";
+  CacheType2["auth"] = "auth";
+  CacheType2["user"] = "user";
+  return CacheType2;
+})(CacheType || {});
+var TssApi = class {
+  auth;
+  jingle;
+  user;
+  constructor(cacheConfiguration) {
+    this.jingle = new JingleModule(this, cacheConfiguration?.jingle ?? new NullCache("jingle"));
+    this.auth = new AuthModule(this, cacheConfiguration?.auth ?? new NullCache("auth"));
+    this.user = new UserModule(this, cacheConfiguration?.user ?? new NullCache("user"));
+  }
+  async fetch(url, config = {}) {
+    config.method = config.method ?? "GET";
+    config.headers = {
+      ...config.headers,
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${await this.auth.getToken()}`
+    };
+    const apiPrefix = process.env.API_URL ?? "https://localhost:8081";
+    const response = await fetch(apiPrefix + "/api/" + url, config);
+    switch (response.status) {
+      case 400:
+        throw new BadRequestException(response.statusText);
+      case 401:
+        throw new UnauthorizedException(response.statusText);
+      case 403:
+        throw new ForbiddenException(response.statusText);
+      case 404:
+        throw new NotFoundException(response.statusText);
+      case 422:
+        throw new UnprocessableEntityException(response.statusText);
+    }
+    return response.json();
+  }
+  async post(url, body) {
+    return this.fetch(url, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+};
+export {
+  AbstractCache,
+  AuthModule,
+  CacheLifetime,
+  CacheType,
+  CookieCache,
+  FilesystemCache,
+  JingleModule,
+  NullCache,
+  OnePasswordCache,
+  TssApi,
+  UserModule
+};

package/dist/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/cache/abstractCache.ts", "../src/cache/cookieCache.ts", "../src/cache/filesystemCache.ts", "../src/cache/nullCache.ts", "../src/cache/onePasswordCache.ts", "../src/api/base.ts", "../src/api/auth.ts", "../src/api/jingle.ts", "../src/api/user.ts", "../src/index.ts"],
+  "sourcesContent": ["import { get } from \"stack-trace\";\n\nexport enum CacheLifetime {\n    Day = 60 * 60 * 24,\n    Week = 60 * 60 * 24 * 7,\n}\n\nexport abstract class AbstractCache {\n    constructor(protected cacheName: string) {}\n\n    public abstract cacheOrGet<T>(callbackWhenEmpty: () => Promise<T>, key?: string, lifetime?: number): Promise<T>;\n\n    public abstract get<T>(key: string): Promise<T | undefined>;\n\n    public abstract set<T>(key: string, value: T, lifetime?: number): void;\n\n    public abstract remove(key: string): void;\n\n    public abstract clear(): void;\n\n    public getCacheKey(): string {\n        const errorMessage = \"Could not determine cache key. Please provide a key manually.\";\n        const trace = get();\n        if (trace.length < 3) {\n            throw new Error(errorMessage);\n        }\n\n        const functionName = get()[2].getFunctionName();\n        if (!functionName) {\n            throw new Error(errorMessage);\n        }\n\n        return functionName;\n    }\n}\n", "import { AbstractCache } from \"./abstractCache\";\n\nexport class CookieCache extends AbstractCache {\n    public cacheOrGet<T>(callbackWhenEmpty: () => Promise<T>, key?: string, lifetime?: number): Promise<T> {\n        // TODO implement\n        return callbackWhenEmpty();\n    }\n\n    public async get<T>(key: string): Promise<T | undefined> {\n        return undefined;\n    }\n\n    public set<T>(key: string, value: T): void {}\n\n    public remove(key: string): void {}\n\n    public clear(): void {}\n}\n", "import { AbstractCache } from \"./abstractCache\";\nimport { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from \"fs\";\nimport path from \"path\";\nimport os from \"os\";\n\ntype CacheItem = {\n    value: any;\n    expiresAt?: number;\n};\n\nexport class FilesystemCache extends AbstractCache {\n    protected initialized = false;\n\n    protected state: { [key: string]: CacheItem } = {};\n\n    public async cacheOrGet<T>(callbackWhenEmpty: () => Promise<T>, key?: string, lifetime?: number): Promise<T> {\n        key = key ?? this.getCacheKey();\n\n        const cachedValue = await this.get<T>(key);\n        if (cachedValue) {\n            return cachedValue;\n        }\n\n        const result = await callbackWhenEmpty();\n        this.set(key, result, lifetime);\n        return result;\n    }\n\n    public async get<T>(key: string): Promise<T | undefined> {\n        if (!this.initialized) {\n            await this._initialize();\n        }\n\n        const expires = this.state[key]?.expiresAt;\n        if (Object.keys(this.state).includes(key) && (expires === undefined || expires > Date.now())) {\n            return this.state[key].value;\n        }\n\n        return undefined;\n    }\n\n    public set<T>(key: string, value: T, lifetime?: number): void {\n        const expiresAt = lifetime ? Date.now() + lifetime : undefined;\n        const content: CacheItem = { value };\n        if (expiresAt) {\n            content.expiresAt = expiresAt;\n        }\n        this.state[key] = content;\n        this.writeState();\n    }\n\n    public remove(key: string): void {\n        delete this.state[key];\n        this.writeState();\n    }\n\n    public clear(): void {\n        this.state = {};\n        unlinkSync(this.getFilePath());\n    }\n\n    public getFilePath() {\n        return path.join(os.homedir(), \".tss\", `${this.cacheName}.json`);\n    }\n\n    protected _initialize() {\n        this.initialized = true;\n        if (existsSync(this.getFilePath())) {\n            this.state = JSON.parse(readFileSync(this.getFilePath(), \"utf8\"));\n        }\n    }\n\n    protected writeState() {\n        if (!existsSync(path.dirname(this.getFilePath()))) {\n            mkdirSync(path.dirname(this.getFilePath()));\n        }\n\n        writeFileSync(this.getFilePath(), JSON.stringify(this.state));\n    }\n}\n", "import { AbstractCache } from \"./abstractCache\";\n\nexport class NullCache extends AbstractCache {\n    public cacheOrGet<T>(callbackWhenEmpty: () => Promise<T>, key?: string, lifetime?: number): Promise<T> {\n        return callbackWhenEmpty();\n    }\n\n    public async get<T>(key: string): Promise<T | undefined> {\n        return undefined;\n    }\n\n    public set<T>(key: string, value: T): void {}\n\n    public remove(key: string): void {}\n\n    public clear(): void {}\n}\n", "import { AbstractCache } from \"./abstractCache\";\nimport { promisify } from \"util\";\nimport { exec } from \"child_process\";\n\nconst asyncExec = promisify(exec);\n\n// TODO error handling\nexport class OnePasswordCache extends AbstractCache {\n    public cacheOrGet<T>(callbackWhenEmpty: () => Promise<T>, key?: string, lifetime?: number): Promise<T> {\n        throw new Error(\"Not implemented, use get() and set()\");\n    }\n\n    public async get<T>(key: string): Promise<T | undefined> {\n        const { stdout, stderr } = await asyncExec(`op item get \"${key}\" --fields label=credential --format json`);\n\n        if (stderr) {\n            console.log(stderr);\n            throw new Error(\"ERROR\");\n        }\n\n        return JSON.parse(stdout).value;\n    }\n\n    public async set<T>(key: string, value: T): Promise<void> {\n        let action = `op item edit '${key}' 'credential=${value}'`;\n\n        try {\n            const t = await this.get(key);\n        } catch (e) {\n            action = `op item create --category=\"API Credential\" --title ${key} 'credential=${value}'`;\n        }\n\n        const { stdout, stderr } = await asyncExec(action);\n\n        if (stderr) {\n            console.log(stderr);\n            throw new Error(\"ERROR\");\n        }\n    }\n\n    public async remove(key: string): Promise<void> {\n        await asyncExec(`op item delete '${key}'`);\n    }\n\n    public clear(): void {\n        // Loopje maken en heel 1password leeg maken?\n    }\n}\n", "import { AbstractCache } from \"../cache\";\nimport { TssApi } from \"../index\";\n\nexport class BaseModule {\n    constructor(protected api: TssApi, protected cache: AbstractCache) {}\n\n    public getCache() {\n        return this.cache;\n    }\n\n    public setCache(cache: AbstractCache) {\n        this.cache = cache;\n    }\n}\n", "import { BaseModule } from \"./base\";\n\nexport class AuthModule extends BaseModule {\n    protected static cacheKey = \"TSS-TOKEN\";\n\n    async getToken(): Promise<string | undefined> {\n        return this.cache.get(AuthModule.cacheKey);\n    }\n\n    async setToken(token: string) {\n        return this.cache.set(AuthModule.cacheKey, token);\n    }\n\n    async removeToken() {\n        return this.cache.remove(AuthModule.cacheKey);\n    }\n}\n", "import { JingleFolder, Jingle } from \"tering-serieuze-types\";\nimport { BaseModule } from \"./base\";\n\nexport class JingleModule extends BaseModule {\n    async getGrouped() {\n        return this.cache.cacheOrGet(() => {\n            return this.api.fetch<JingleFolder[]>(\"jingle/grouped\");\n        });\n    }\n\n    async getAll() {\n        return this.cache.cacheOrGet(() => {\n            return this.api.fetch<Jingle[]>(\"jingle\");\n        });\n    }\n\n    async play(folder: string, file: string) {\n        console.log(`Playing jingle ${folder}/${file}`);\n        return this.api.post(\"jingle/play\", { folder, file });\n    }\n}\n", "import { BaseModule } from \"./base\";\nimport { User } from \"tering-serieuze-types\";\n\nexport class UserModule extends BaseModule {\n    async get(userId?: string) {\n        return this.cache.cacheOrGet(() => {\n            const userIdParam = userId ? `/${userId}` : \"\";\n            return this.api.fetch<User>(`user${userIdParam}`);\n        });\n    }\n}\n", "import { AbstractCache, NullCache } from \"./cache\";\nimport { AuthModule, JingleModule, UserModule } from \"./api\";\nimport {\n    BadRequestException,\n    ForbiddenException,\n    NotFoundException,\n    UnauthorizedException,\n    UnprocessableEntityException,\n} from \"@nestjs/common\";\n\nexport * from \"./api\";\nexport * from \"./cache\";\n\nexport interface SDKRequestInit extends RequestInit {\n    method?: \"GET\" | \"POST\" | \"PUT\" | \"DELETE\" | \"PATCH\";\n}\n\nexport enum CacheType {\n    jingle = \"jingle\",\n    auth = \"auth\",\n    user = \"user\",\n}\n\nexport type CacheConfiguration = {\n    [key in keyof typeof CacheType]?: AbstractCache;\n};\n\nexport class TssApi {\n    auth: AuthModule;\n\n    jingle: JingleModule;\n\n    user: UserModule;\n\n    constructor(cacheConfiguration?: CacheConfiguration) {\n        this.jingle = new JingleModule(this, cacheConfiguration?.jingle ?? new NullCache(\"jingle\"));\n        this.auth = new AuthModule(this, cacheConfiguration?.auth ?? new NullCache(\"auth\"));\n        this.user = new UserModule(this, cacheConfiguration?.user ?? new NullCache(\"user\"));\n    }\n\n    async fetch<T>(url: string, config: SDKRequestInit = {}) {\n        config.method = config.method ?? \"GET\";\n        config.headers = {\n            ...config.headers,\n            \"Content-Type\": \"application/json\",\n            Authorization: `Bearer ${await this.auth.getToken()}`,\n        };\n\n        const apiPrefix = process.env.API_URL ?? \"https://localhost:8081\";\n        const response = await fetch(apiPrefix + \"/api/\" + url, config);\n        switch (response.status) {\n            case 400:\n                throw new BadRequestException(response.statusText);\n            case 401:\n                throw new UnauthorizedException(response.statusText);\n            case 403:\n                throw new ForbiddenException(response.statusText);\n            case 404:\n                throw new NotFoundException(response.statusText);\n            case 422:\n                throw new UnprocessableEntityException(response.statusText);\n        }\n\n        return response.json() as Promise<T>;\n    }\n\n    async post<T>(url: string, body: any) {\n        return this.fetch<T>(url, {\n            method: \"POST\",\n            body: JSON.stringify(body),\n        });\n    }\n}\n"],
+  "mappings": "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",
+  "names": ["CacheLifetime", "CacheType"]
+}

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./src";
+export * from "./src/api";
+export * from "./src/cache";

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "tering-serieuze-sdk",
+  "version": "1.0.0",
+  "description": "Teringserieuze sdk",
+  "author": "Frank",
+  "main": "dist/index.mjs",
+  "types": "index.d.ts",
+  "type": "module",
+  "scripts": {
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
+    "dev": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.mjs --packages=external --sourcemap=external --format=esm --watch",
+    "build": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.mjs --packages=external --sourcemap=external --format=esm",
+    "webstorm-integration": "vitest --watch --reporter=dot --reporter=json --outputFile=.vitest-result.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@gitlab.com/tering-serieuze-shit/tering-serieuze-sdk.git"
+  },
+  "license": "ISC",
+  "bugs": {
+    "url": "https://gitlab.com/tering-serieuze-shit/tering-serieuze-sdk/issues"
+  },
+  "homepage": "https://gitlab.com/tering-serieuze-shit/tering-serieuze-sdk#readme",
+  "dependencies": {
+    "@nestjs/common": "^9.3.9",
+    "@types/node": "^18.11.18",
+    "stack-trace": "^1.0.0-pre2",
+    "tering-serieuze-types": "^1.8.4"
+  },
+  "devDependencies": {
+    "@types/stack-trace": "^0.0.30",
+    "@vitest/coverage-c8": "^0.28.5",
+    "esbuild": "^0.16.12",
+    "prettier": "^2.8.1",
+    "vitest": "^0.28.5"
+  }
+}

package/src/api/auth.ts

@@ -0,0 +1,17 @@
+import { BaseModule } from "./base";
+
+export class AuthModule extends BaseModule {
+    protected static cacheKey = "TSS-TOKEN";
+
+    async getToken(): Promise<string | undefined> {
+        return this.cache.get(AuthModule.cacheKey);
+    }
+
+    async setToken(token: string) {
+        return this.cache.set(AuthModule.cacheKey, token);
+    }
+
+    async removeToken() {
+        return this.cache.remove(AuthModule.cacheKey);
+    }
+}

package/src/api/base.ts

@@ -0,0 +1,14 @@
+import { AbstractCache } from "../cache";
+import { TssApi } from "../index";
+
+export class BaseModule {
+    constructor(protected api: TssApi, protected cache: AbstractCache) {}
+
+    public getCache() {
+        return this.cache;
+    }
+
+    public setCache(cache: AbstractCache) {
+        this.cache = cache;
+    }
+}

package/src/api/index.ts

@@ -0,0 +1,3 @@
+export * from "./auth";
+export * from "./jingle";
+export * from "./user";

package/src/api/jingle.ts

@@ -0,0 +1,21 @@
+import { JingleFolder, Jingle } from "tering-serieuze-types";
+import { BaseModule } from "./base";
+
+export class JingleModule extends BaseModule {
+    async getGrouped() {
+        return this.cache.cacheOrGet(() => {
+            return this.api.fetch<JingleFolder[]>("jingle/grouped");
+        });
+    }
+
+    async getAll() {
+        return this.cache.cacheOrGet(() => {
+            return this.api.fetch<Jingle[]>("jingle");
+        });
+    }
+
+    async play(folder: string, file: string) {
+        console.log(`Playing jingle ${folder}/${file}`);
+        return this.api.post("jingle/play", { folder, file });
+    }
+}

package/src/api/user.ts

@@ -0,0 +1,11 @@
+import { BaseModule } from "./base";
+import { User } from "tering-serieuze-types";
+
+export class UserModule extends BaseModule {
+    async get(userId?: string) {
+        return this.cache.cacheOrGet(() => {
+            const userIdParam = userId ? `/${userId}` : "";
+            return this.api.fetch<User>(`user${userIdParam}`);
+        });
+    }
+}

package/src/cache/abstractCache.ts

@@ -0,0 +1,35 @@
+import { get } from "stack-trace";
+
+export enum CacheLifetime {
+    Day = 60 * 60 * 24,
+    Week = 60 * 60 * 24 * 7,
+}
+
+export abstract class AbstractCache {
+    constructor(protected cacheName: string) {}
+
+    public abstract cacheOrGet<T>(callbackWhenEmpty: () => Promise<T>, key?: string, lifetime?: number): Promise<T>;
+
+    public abstract get<T>(key: string): Promise<T | undefined>;
+
+    public abstract set<T>(key: string, value: T, lifetime?: number): void;
+
+    public abstract remove(key: string): void;
+
+    public abstract clear(): void;
+
+    public getCacheKey(): string {
+        const errorMessage = "Could not determine cache key. Please provide a key manually.";
+        const trace = get();
+        if (trace.length < 3) {
+            throw new Error(errorMessage);
+        }
+
+        const functionName = get()[2].getFunctionName();
+        if (!functionName) {
+            throw new Error(errorMessage);
+        }
+
+        return functionName;
+    }
+}

package/src/cache/cookieCache.ts

@@ -0,0 +1,18 @@
+import { AbstractCache } from "./abstractCache";
+
+export class CookieCache extends AbstractCache {
+    public cacheOrGet<T>(callbackWhenEmpty: () => Promise<T>, key?: string, lifetime?: number): Promise<T> {
+        // TODO implement
+        return callbackWhenEmpty();
+    }
+
+    public async get<T>(key: string): Promise<T | undefined> {
+        return undefined;
+    }
+
+    public set<T>(key: string, value: T): void {}
+
+    public remove(key: string): void {}
+
+    public clear(): void {}
+}

package/src/cache/filesystemCache.ts

@@ -0,0 +1,80 @@
+import { AbstractCache } from "./abstractCache";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import path from "path";
+import os from "os";
+
+type CacheItem = {
+    value: any;
+    expiresAt?: number;
+};
+
+export class FilesystemCache extends AbstractCache {
+    protected initialized = false;
+
+    protected state: { [key: string]: CacheItem } = {};
+
+    public async cacheOrGet<T>(callbackWhenEmpty: () => Promise<T>, key?: string, lifetime?: number): Promise<T> {
+        key = key ?? this.getCacheKey();
+
+        const cachedValue = await this.get<T>(key);
+        if (cachedValue) {
+            return cachedValue;
+        }
+
+        const result = await callbackWhenEmpty();
+        this.set(key, result, lifetime);
+        return result;
+    }
+
+    public async get<T>(key: string): Promise<T | undefined> {
+        if (!this.initialized) {
+            await this._initialize();
+        }
+
+        const expires = this.state[key]?.expiresAt;
+        if (Object.keys(this.state).includes(key) && (expires === undefined || expires > Date.now())) {
+            return this.state[key].value;
+        }
+
+        return undefined;
+    }
+
+    public set<T>(key: string, value: T, lifetime?: number): void {
+        const expiresAt = lifetime ? Date.now() + lifetime : undefined;
+        const content: CacheItem = { value };
+        if (expiresAt) {
+            content.expiresAt = expiresAt;
+        }
+        this.state[key] = content;
+        this.writeState();
+    }
+
+    public remove(key: string): void {
+        delete this.state[key];
+        this.writeState();
+    }
+
+    public clear(): void {
+        this.state = {};
+        unlinkSync(this.getFilePath());
+    }
+
+    public getFilePath() {
+        return path.join(os.homedir(), ".tss", `${this.cacheName}.json`);
+    }
+
+    protected _initialize() {
+        this.initialized = true;
+        if (existsSync(this.getFilePath())) {
+            this.state = JSON.parse(readFileSync(this.getFilePath(), "utf8"));
+        }
+    }
+
+    protected writeState() {
+        if (!existsSync(path.dirname(this.getFilePath()))) {
+            mkdirSync(path.dirname(this.getFilePath()));
+        }
+
+        writeFileSync(this.getFilePath(), JSON.stringify(this.state));
+    }
+}

package/src/cache/index.ts

@@ -0,0 +1,5 @@
+export * from "./abstractCache";
+export * from "./cookieCache";
+export * from "./filesystemCache";
+export * from "./nullCache";
+export * from "./onePasswordCache";

package/src/cache/nullCache.ts

@@ -0,0 +1,17 @@
+import { AbstractCache } from "./abstractCache";
+
+export class NullCache extends AbstractCache {
+    public cacheOrGet<T>(callbackWhenEmpty: () => Promise<T>, key?: string, lifetime?: number): Promise<T> {
+        return callbackWhenEmpty();
+    }
+
+    public async get<T>(key: string): Promise<T | undefined> {
+        return undefined;
+    }
+
+    public set<T>(key: string, value: T): void {}
+
+    public remove(key: string): void {}
+
+    public clear(): void {}
+}

package/src/cache/onePasswordCache.ts

@@ -0,0 +1,48 @@
+import { AbstractCache } from "./abstractCache";
+import { promisify } from "util";
+import { exec } from "child_process";
+
+const asyncExec = promisify(exec);
+
+// TODO error handling
+export class OnePasswordCache extends AbstractCache {
+    public cacheOrGet<T>(callbackWhenEmpty: () => Promise<T>, key?: string, lifetime?: number): Promise<T> {
+        throw new Error("Not implemented, use get() and set()");
+    }
+
+    public async get<T>(key: string): Promise<T | undefined> {
+        const { stdout, stderr } = await asyncExec(`op item get "${key}" --fields label=credential --format json`);
+
+        if (stderr) {
+            console.log(stderr);
+            throw new Error("ERROR");
+        }
+
+        return JSON.parse(stdout).value;
+    }
+
+    public async set<T>(key: string, value: T): Promise<void> {
+        let action = `op item edit '${key}' 'credential=${value}'`;
+
+        try {
+            const t = await this.get(key);
+        } catch (e) {
+            action = `op item create --category="API Credential" --title ${key} 'credential=${value}'`;
+        }
+
+        const { stdout, stderr } = await asyncExec(action);
+
+        if (stderr) {
+            console.log(stderr);
+            throw new Error("ERROR");
+        }
+    }
+
+    public async remove(key: string): Promise<void> {
+        await asyncExec(`op item delete '${key}'`);
+    }
+
+    public clear(): void {
+        // Loopje maken en heel 1password leeg maken?
+    }
+}

package/src/index.ts

@@ -0,0 +1,73 @@
+import { AbstractCache, NullCache } from "./cache";
+import { AuthModule, JingleModule, UserModule } from "./api";
+import {
+    BadRequestException,
+    ForbiddenException,
+    NotFoundException,
+    UnauthorizedException,
+    UnprocessableEntityException,
+} from "@nestjs/common";
+
+export * from "./api";
+export * from "./cache";
+
+export interface SDKRequestInit extends RequestInit {
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+}
+
+export enum CacheType {
+    jingle = "jingle",
+    auth = "auth",
+    user = "user",
+}
+
+export type CacheConfiguration = {
+    [key in keyof typeof CacheType]?: AbstractCache;
+};
+
+export class TssApi {
+    auth: AuthModule;
+
+    jingle: JingleModule;
+
+    user: UserModule;
+
+    constructor(cacheConfiguration?: CacheConfiguration) {
+        this.jingle = new JingleModule(this, cacheConfiguration?.jingle ?? new NullCache("jingle"));
+        this.auth = new AuthModule(this, cacheConfiguration?.auth ?? new NullCache("auth"));
+        this.user = new UserModule(this, cacheConfiguration?.user ?? new NullCache("user"));
+    }
+
+    async fetch<T>(url: string, config: SDKRequestInit = {}) {
+        config.method = config.method ?? "GET";
+        config.headers = {
+            ...config.headers,
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${await this.auth.getToken()}`,
+        };
+
+        const apiPrefix = process.env.API_URL ?? "https://localhost:8081";
+        const response = await fetch(apiPrefix + "/api/" + url, config);
+        switch (response.status) {
+            case 400:
+                throw new BadRequestException(response.statusText);
+            case 401:
+                throw new UnauthorizedException(response.statusText);
+            case 403:
+                throw new ForbiddenException(response.statusText);
+            case 404:
+                throw new NotFoundException(response.statusText);
+            case 422:
+                throw new UnprocessableEntityException(response.statusText);
+        }
+
+        return response.json() as Promise<T>;
+    }
+
+    async post<T>(url: string, body: any) {
+        return this.fetch<T>(url, {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+    }
+}

package/test/api/base.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { BaseModule } from "../../src/api/base";
+import { NullCache } from "../../src/cache";
+import { TssApi } from "../../src/index";
+
+describe("Base module", () => {
+    it("returns the cache", () => {
+        const cache = new NullCache("base");
+        const base = new BaseModule(new TssApi(), cache);
+        expect(base.getCache()).toBe(cache);
+    });
+
+    it("sets the cache", () => {
+        const cache = new NullCache("base");
+        const base = new BaseModule(new TssApi(), cache);
+        const newCache = new NullCache("base");
+        base.setCache(newCache);
+        expect(base.getCache()).toBe(newCache);
+    });
+});

package/test/api/jingle.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { TssApi } from "../../src";
+import { NullCache, OnePasswordCache } from "../../src/cache";
+
+describe("Jingle API", () => {
+    const api = new TssApi({
+        jingle: new NullCache("jingle"),
+        auth: new OnePasswordCache("TSS-TOKEN"),
+    });
+
+    it("Retrieves jingles when calling getGrouped", async () => {
+        const items = await api.jingle.getGrouped();
+
+        expect(items.length).toBeGreaterThan(0);
+        expect(items[0].folder).not.toBe("");
+        expect(items[0].jingles).toBeInstanceOf(Array);
+        expect(items[0].jingles[0].file).not.toBe("");
+    });
+
+    it("Retrieves jingles when calling getAll", async () => {
+        const items = await api.jingle.getAll();
+
+        expect(items.length).toBeGreaterThan(0);
+        expect(items[0].folder).not.toBe("");
+        expect(items[0].file).not.toBe("");
+    });
+
+    it("Plays a jingle", async () => {
+        const result = await api.jingle.play("keeskankerkachel", "aan.mp3");
+        // TODO fix dit
+        expect(result.success).toBe(true);
+    });
+});

package/test/cache/filesystemCache.test.ts

@@ -0,0 +1,141 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { FilesystemCache } from "../../src/cache";
+import { existsSync, unlinkSync, writeFileSync } from "fs";
+import path from "path";
+
+describe("filesystemCache", () => {
+    let cache: FilesystemCache;
+
+    beforeEach(() => {
+        cache = new FilesystemCache(`fs-test-${Math.random()}`);
+    });
+
+    afterEach(() => {
+        if (existsSync(cache.getFilePath())) {
+            unlinkSync(cache.getFilePath());
+        }
+
+        vi.restoreAllMocks();
+    });
+
+    it("Should call the callback only once", async () => {
+        const callback = vi.fn(() => Promise.resolve(1));
+        const result = await cache.cacheOrGet(callback, "key");
+        expect(result).toBe(1);
+        expect(callback).toBeCalledTimes(1);
+
+        await Promise.all([
+            cache.cacheOrGet(callback, "key"),
+            cache.cacheOrGet(callback, "key"),
+            cache.cacheOrGet(callback, "key"),
+        ]);
+        expect(callback).toBeCalledTimes(1);
+    });
+
+    it("Should call the callback only once when using the same key", async () => {
+        const key = "test";
+        const callback = vi.fn(() => Promise.resolve(1));
+        const result = await cache.cacheOrGet(callback, key);
+        expect(result).toBe(1);
+        expect(callback).toBeCalledTimes(1);
+
+        await cache.cacheOrGet(callback, key);
+        expect(callback).toBeCalledTimes(1);
+    });
+
+    it("Should call the callback twice when using different keys", async () => {
+        const callback = vi.fn(() => Promise.resolve(1));
+        const result = await cache.cacheOrGet(callback, "key");
+        expect(result).toBe(1);
+        expect(callback).toBeCalledTimes(1);
+
+        await cache.cacheOrGet(callback, `key-${Math.random()}`);
+        expect(callback).toBeCalledTimes(2);
+    });
+
+    it("Should throw an error when no key is passed and the function name can not be determined", async () => {
+        const callback = () => Promise.resolve(1);
+        await expect(cache.cacheOrGet(callback)).rejects.toThrowError();
+    });
+
+    it("Should use the function name as key, when no key is passed", async () => {
+        let expected: number = 0;
+        await (async function doeHet() {
+            expected = await cache.cacheOrGet(() => Promise.resolve(50));
+        })();
+
+        const nonCalledFunction = vi.fn(() => Promise.resolve(1));
+        const result = await cache.cacheOrGet(nonCalledFunction, "doeHet");
+        expect(result).toBeGreaterThan(0);
+        expect(result).toBe(expected);
+        expect(nonCalledFunction).toBeCalledTimes(0);
+    });
+
+    it("Should return the set value", async () => {
+        const key = "test";
+        const value = 1;
+        cache.set(key, value);
+        const result = await cache.cacheOrGet(() => Promise.resolve(2), key);
+        expect(result).toBe(value);
+    });
+
+    it("Should be able to remove a value", async () => {
+        const key = "test";
+        const otherKey = "test2";
+        const correctValue = 123;
+        const otherCorrectValue = 456;
+        cache.set(key, 1);
+        cache.set(otherKey, otherCorrectValue);
+        cache.remove(key);
+
+        const result = await cache.cacheOrGet(() => Promise.resolve(correctValue), key);
+        expect(result).toBe(correctValue);
+
+        const cachedValue = await cache.cacheOrGet(() => Promise.resolve(1), otherKey);
+        expect(cachedValue).toBe(otherCorrectValue);
+    });
+
+    it("Should be able to clear the cache", async () => {
+        expect(existsSync(cache.getFilePath())).toBe(false);
+        cache.set("test", 1);
+        expect(existsSync(cache.getFilePath())).toBe(true);
+        cache.clear();
+        expect(existsSync(cache.getFilePath())).toBe(false);
+    });
+
+    it("Should use the cache when making a second instance", async () => {
+        const instance = new FilesystemCache("testfile2");
+        const callback = vi.fn(() => Promise.resolve(123));
+        await instance.cacheOrGet(callback, "test");
+
+        const instance2 = new FilesystemCache("testfile2");
+        await instance2.cacheOrGet(callback, "test");
+
+        expect(callback).toBeCalledTimes(1);
+
+        instance2.clear();
+    });
+
+    it("Should use the cache if a cache file already exists", async () => {
+        cache.set("test", 123);
+
+        const cacheName = path.basename(cache.getFilePath(), path.extname(cache.getFilePath()));
+        const instance = new FilesystemCache(cacheName);
+        const callback = vi.fn(() => Promise.resolve(789));
+
+        const result = await instance.cacheOrGet(callback, "test");
+        expect(result).toBe(123);
+
+        instance.clear();
+    });
+
+    it("Should be able to set a custom cache lifetime", async () => {
+        const result = await cache.cacheOrGet(() => Promise.resolve(1), "test", 1);
+        const result2 = await cache.cacheOrGet(() => Promise.resolve(1), "test", 1);
+        expect(result).toBe(1);
+        expect(result2).toBe(1);
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+        const result3 = await cache.cacheOrGet(() => Promise.resolve(2), "test", 1);
+        expect(result3).toBe(2);
+    });
+});

package/test/cache/nullCache.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it, vi } from "vitest";
+import { NullCache } from "../../src/cache";
+
+describe("NullCache", () => {
+    const cache = new NullCache("nullCache");
+
+    it("should return the same value", async () => {
+        const input = "hoi";
+        const output = await cache.cacheOrGet(() => Promise.resolve(input));
+        expect(output).toBe(input);
+    });
+
+    it("should return the same value when using a key", async () => {
+        const input = "hoi";
+        const callback = vi.fn(() => Promise.resolve(input));
+        const output = await cache.cacheOrGet(callback, "key");
+        expect(input).toBe(output);
+        expect(callback).toBeCalledTimes(1);
+    });
+
+    it("should not do anything when calling set", async () => {
+        const key = "key";
+        const input = "hoi";
+        cache.set(key, "invalid value");
+        const output = await cache.cacheOrGet(() => Promise.resolve(input), key);
+        expect(input).toBe(output);
+    });
+
+    it("Can't test remove and clear", () => {
+        const coverage = 100;
+        cache.remove("test");
+        cache.clear();
+        expect(coverage).toBe(100);
+    });
+
+    it("Should throw an error when no key is provided", () => {
+        let catchedException = false;
+        try {
+            cache.getCacheKey();
+        } catch (e) {
+            catchedException = true;
+        }
+
+        // Can't use expect().toThrow() since it uses a named function, which screws up the context
+        expect(catchedException).toBe(true);
+    });
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "strict": true,
+    "target": "ESNext",
+    "module": "ES2022",
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "moduleResolution": "Node",
+    "strictNullChecks": true,
+    "noImplicitAny": true
+  }
+}