@singularlogic/coreplatts 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,177 @@
+import { AxiosInstance } from 'axios';
+
+interface Updated {
+    by?: string;
+    at?: Date;
+}
+interface Meta {
+    creator?: string;
+    description?: string;
+    title?: string;
+    date_creation?: Date | null;
+    write?: string[];
+    read?: string[];
+    tags?: string[];
+    update?: Updated;
+}
+interface FileModel {
+    _id?: string;
+    meta: Meta;
+    folder: string;
+    ancestors?: string[];
+    original_title: string;
+    file_type: string;
+    size: number;
+    total?: number;
+}
+interface FolderModel {
+    _id: string;
+    meta: Meta;
+    parent: string;
+    ancestors: string[];
+    files: string[];
+    folders: string[];
+    level: number;
+    size: number;
+}
+interface FolderList {
+    files: FileModel[];
+    folder: FolderModel[];
+}
+
+declare class File$1 implements FileModel {
+    protected _httpClient: AxiosInstance;
+    _id?: string;
+    meta: Meta;
+    folder: string;
+    ancestors?: string[];
+    original_title: string;
+    file_type: string;
+    size: number;
+    total?: number;
+    _managementURL: string;
+    private _fileConsumer;
+    constructor(struct: FileModel, _httpClient: AxiosInstance);
+    getFilename(): string;
+    download(concurrencyLimit?: number, token?: string): Promise<Uint8Array>;
+}
+
+declare class Folder implements FolderModel {
+    protected _httpClient: AxiosInstance;
+    _id: string;
+    meta: Meta;
+    parent: string;
+    ancestors: string[];
+    files: string[];
+    folders: string[];
+    level: number;
+    size: number;
+    _managementURL: string;
+    private _fileConsumer;
+    constructor(struct: FolderModel, _httpClient: AxiosInstance);
+    getName(): string | undefined;
+    listItems(token?: string): Promise<FolderList>;
+    getFileByID(id: string, token?: string): Promise<File$1>;
+    getFileByName(name: string, token?: string): Promise<File$1>;
+    uploadFile(file: File, meta: Meta, chunkSize?: number, concurrentLimit?: number, timeout?: number, token?: string, onProgress?: (uploaded: number, total: number) => void): Promise<File$1>;
+}
+
+interface OidcToken {
+    access_token: string;
+    expires_in: number;
+    refresh_expires_in: number;
+    refresh_token: string;
+    token_type: string;
+    scope: string;
+}
+interface UserAttributes {
+    viewer_in_user_attr?: string[];
+    editor_in_user_attr?: string[];
+}
+interface UserAccess {
+    manageGroupMembership: boolean;
+    view: boolean;
+    mapRoles: boolean;
+    impersonate: boolean;
+    manage: boolean;
+}
+interface User$1 {
+    id: string;
+    username: string;
+    firstName: string;
+    lastName: string;
+    email: string;
+    emailVerified: boolean;
+    attributes: UserAttributes;
+    createdTimestamp: number;
+    enabled: boolean;
+    totp: boolean;
+    disableableCredentialTypes: string[];
+    requiredActions: string[];
+    notBefore: number;
+    access: UserAccess;
+}
+
+interface Group$1 {
+    id?: string;
+    name: string;
+    path: string;
+    subGroups?: string[];
+    attributes?: {
+        [key: string]: any[];
+    };
+}
+declare enum Role {
+    ADMIN,
+    MEMBER
+}
+interface UserRoles {
+    [email: string]: Role;
+}
+
+interface Bucket {
+    _id?: string;
+    name: string;
+    creation_date?: Date;
+}
+
+interface IClient$1 {
+    login(email: string, password: string): Promise<OidcToken>;
+    myUser(token?: string): Promise<User$1>;
+    allOrganizations(token?: string): Promise<Group$1[]>;
+    myOrganizations(token?: string): Promise<Group$1[]>;
+    organizationByID(id: string, token?: string): Promise<Group$1>;
+    organizationByName(name: string, token?: string): Promise<Group$1>;
+    createOrganization(name: string, token?: string): Promise<Bucket>;
+    addToOrganization(organization: string, users: UserRoles, token?: string): void;
+    getFolderByName(name: string, token?: string): Promise<Folder>;
+    getFolderByID(id: string, token?: string): Promise<Folder>;
+    removeOrganizationByID(organization: string, token?: string): Promise<Bucket>;
+    register(email: string, password: string, password_confirm: string, firstName: string, lastName: string): void;
+}
+declare class Client implements IClient$1 {
+    private _userConsumer;
+    private _groupConsumer;
+    private _bucketConsumer;
+    private _folderConsumer;
+    constructor(_managementURL: string, _accountURL: string);
+    private _setSession;
+    login(email: string, password: string): Promise<OidcToken>;
+    myUser(token: string): Promise<User$1>;
+    allOrganizations(token: string): Promise<Group$1[]>;
+    myOrganizations(token: string): Promise<Group$1[]>;
+    organizationByID(id: string, token: string): Promise<Group$1>;
+    organizationByName(name: string, token: string): Promise<Group$1>;
+    createOrganization(name: string, token: string): Promise<Bucket>;
+    removeOrganizationByID(organization: string, token: string): Promise<Bucket>;
+    addToOrganization(organization: string, users: UserRoles, token: string): void;
+    register(email: string, password: string, password_confirm: string, firstName: string, lastName: string): Promise<any>;
+    getFolderByName(name: string, token: string): Promise<Folder>;
+    getFolderByID(id: string, token: string): Promise<Folder>;
+}
+
+type User = User$1;
+type Group = Group$1;
+type IClient = IClient$1;
+
+export { Client, type Group, type IClient, type User };

package/dist/index.js

@@ -0,0 +1,879 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Client: () => Client
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_axios = __toESM(require("axios"));
+
+// src/apis/base.consumer.ts
+var BaseConsumer = class {
+  constructor(_httpClient, _requestPath) {
+    this._httpClient = _httpClient;
+    this._requestPath = _requestPath;
+    this._httpClient = _httpClient;
+    this._basePath = this._httpClient.defaults["baseURL"];
+    this.path = this._basePath + "/" + _requestPath;
+  }
+  getOne(additional_path = "", params = null, token) {
+    let config = {};
+    if (params === null) {
+      config = {
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": "Bearer " + token
+        }
+      };
+    } else {
+      config = {
+        params,
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": "Bearer " + token
+        }
+      };
+    }
+    return this._httpClient.get(this.path + additional_path, config).then((resp) => {
+      return resp.data;
+    }).catch((error) => {
+      console.error(`\u274C Can't retrieve requsted entity:`, error);
+      return null;
+    });
+  }
+  getMany(additional_path = "", params = null, token) {
+    let config = {};
+    if (params === null) {
+      config = {
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": "Bearer " + token
+        }
+      };
+    } else {
+      config = {
+        params,
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": "Bearer " + token
+        }
+      };
+    }
+    return this._httpClient.get(this.path + additional_path, config).then((resp) => {
+      return resp.data;
+    }).catch((error) => {
+      console.error(`\u274C Can't retrieve requsted entities:`, error);
+      return null;
+    });
+  }
+  post(additional_path = "", payload, extraHeaders, token) {
+    const config = {
+      headers: __spreadValues({
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      }, extraHeaders)
+    };
+    return this._httpClient.post(this.path + additional_path, payload, config).then((resp) => resp.data).catch((error) => {
+      console.error(`\u274C Error in posting:`, error);
+      return null;
+    });
+  }
+  delete(id, token) {
+    let config = {
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": "Bearer " + token
+      }
+    };
+    return this._httpClient.delete(this.path + id, config).then((resp) => resp.data).catch((error) => {
+      console.error(`\u274C Error deleting ${id}:`, error);
+      return null;
+    });
+  }
+};
+
+// src/apis/account/user.consumer.ts
+var _namespace = "user/";
+var UserConsumer = class extends BaseConsumer {
+  // private _accountBase:string;
+  constructor(_httpClient) {
+    super(_httpClient, _namespace);
+    this._client = _httpClient;
+  }
+  login(email, password) {
+    let config = {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    };
+    let data = {
+      "username": email,
+      "password": password
+    };
+    return this._client.post(this.path, data, config).then((resp) => {
+      return resp.data;
+    });
+  }
+  getUser(token) {
+    return this.getOne("", null, token);
+  }
+  register(email, password, firstName, lastName) {
+    let config = {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    };
+    let data = {
+      "email": email,
+      "password": password,
+      "last_name": lastName,
+      "first_name": firstName
+    };
+    return this._client.post(this.path + "/register/", data, config).then((resp) => {
+      return resp.data;
+    }).catch((err) => {
+      console.log(err);
+    });
+  }
+};
+
+// src/apis/account/group.consumer.ts
+var _namespace2 = "group/";
+var GroupConsumer = class extends BaseConsumer {
+  constructor(_httpClient) {
+    super(_httpClient, _namespace2);
+    this._client = _httpClient;
+  }
+  getAllGroups(token) {
+    return this.getMany("all", null, token);
+  }
+  getUserGroups(token) {
+    return this.getMany("", null, token);
+  }
+  getGroupByID(id, token) {
+    return this.getOne("id/" + id, null, token);
+  }
+  getGroupByName(name, token) {
+    return this.getOne("name/" + name, null, token);
+  }
+  postGroup(name, token) {
+    const postGroup = {
+      name,
+      path: "/",
+      subGroups: [],
+      attributes: {},
+      id: void 0
+    };
+    return this.post("", postGroup, void 0, token);
+  }
+  addUsers(group_name, input, token) {
+    let payload = {
+      users: Object.entries(input).map(([email, role]) => ({
+        [email]: { admin: role === "admin" /* ADMIN */ }
+      }))
+    };
+    let config = {
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": "Bearer " + token
+      }
+    };
+    this._client.post(this.path + "name/" + group_name, payload, config);
+  }
+  deleteGroup(id, token) {
+    return this.delete("id/" + id, token);
+  }
+};
+
+// src/apis/management/bucket.consumer.ts
+var _namespace3 = "bucket";
+var BucketConsumer = class extends BaseConsumer {
+  constructor(_httpClient) {
+    super(_httpClient, _namespace3);
+  }
+  postBucket(id, name, token) {
+    const postBucket = {
+      name,
+      _id: id,
+      creation_date: void 0
+    };
+    return this.post("", postBucket, void 0, token);
+  }
+  deleteBucket(id, token) {
+    return this.delete("/" + id, token);
+  }
+};
+
+// src/utils/utils.ts
+function withValidToken(fn, accountsAPI) {
+  return function(...args) {
+    return __async(this, null, function* () {
+      const isStorageAvailable = typeof localStorage !== "undefined";
+      const now = Math.floor(Date.now() / 1e3);
+      if (!isStorageAvailable) {
+        console.warn("\u26A0\uFE0F localStorage not available. You must pass token manually.");
+        return Promise.resolve(fn.apply(this, args));
+      }
+      let token = localStorage.getItem("token");
+      const refreshToken = localStorage.getItem("refresh_token");
+      const exp = Number(localStorage.getItem("exp") || "0");
+      const refreshExp = Number(localStorage.getItem("refresh_exp") || "0");
+      if (!token || now >= exp) {
+        if (!refreshToken || now >= refreshExp) {
+          console.warn("\u26A0\uFE0F Session expired. Please log in again.");
+          return Promise.resolve(fn.apply(this, args));
+        }
+        try {
+          const response = yield fetch(`${accountsAPI}/user/refresh`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ refresh_token: refreshToken })
+          });
+          if (!response.ok) throw new Error("Token refresh failed");
+          const session = yield response.json();
+          const newExp = now + session.expires_in;
+          const newRefreshExp = now + session.refresh_expires_in;
+          localStorage.setItem("token", session.access_token);
+          localStorage.setItem("refresh_token", session.refresh_token);
+          localStorage.setItem("exp", String(newExp));
+          localStorage.setItem("refresh_exp", String(newRefreshExp));
+          token = session.access_token;
+        } catch (e) {
+          console.error("\u{1F510} Token refresh failed:", e);
+          throw new Error("Could not refresh session.");
+        }
+      }
+      const result = fn.apply(this, [...args, token]);
+      return result instanceof Promise ? result : Promise.resolve(result);
+    });
+  };
+}
+function runConcurrent(items, fn, limit) {
+  return __async(this, null, function* () {
+    const queue = [...items];
+    const running = [];
+    const runNext = () => __async(this, null, function* () {
+      const item = queue.shift();
+      if (!item) return;
+      const p = fn(item).finally(() => {
+        running.splice(running.indexOf(p), 1);
+      });
+      running.push(p);
+      if (running.length >= limit) {
+        yield Promise.race(running);
+      }
+      return runNext();
+    });
+    const initialTasks = Array.from(
+      { length: Math.min(limit, items.length) },
+      runNext
+      // Start up to `limit` runners in parallel
+    );
+    yield Promise.all(initialTasks);
+    yield Promise.all(running);
+  });
+}
+function runConcurrentWithResults(items, fn, limit) {
+  return __async(this, null, function* () {
+    const results = new Array(items.length);
+    const queue = items.map((item, index) => ({ item, index }));
+    const running = [];
+    const runNext = () => __async(this, null, function* () {
+      const next = queue.shift();
+      if (!next) return;
+      const { item, index } = next;
+      const p = fn(item, index).then((res) => {
+        results[index] = res;
+      }).finally(() => {
+        running.splice(running.indexOf(p), 1);
+      });
+      running.push(p);
+      if (running.length >= limit) {
+        yield Promise.race(running);
+      }
+      return runNext();
+    });
+    const initial = Array.from({ length: Math.min(limit, items.length) }, runNext);
+    yield Promise.all(initial);
+    yield Promise.all(running);
+    return results;
+  });
+}
+function splitFileIntoChunks(file, chunkSize) {
+  const chunks = [];
+  for (let i = 0; i < Math.ceil(file.size / chunkSize); i++) {
+    const start = i * chunkSize;
+    const end = Math.min(file.size, start + chunkSize);
+    chunks.push(file.slice(start, end));
+  }
+  return chunks;
+}
+function createChunkUploader(chunks, timeoutSeconds) {
+  let uploadedChunks = 0;
+  const totalChunks = chunks.length;
+  return (part) => __async(this, null, function* () {
+    var _a, _b;
+    const chunkIndex = part.number - 1;
+    const blob = chunks[chunkIndex];
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutSeconds * 1e3);
+    try {
+      const response = yield fetch(part.presigned_url, {
+        method: "PUT",
+        body: blob,
+        signal: controller.signal,
+        headers: {
+          "Content-Type": "application/octet-stream"
+        }
+      });
+      if (response.ok) {
+        const etag = (_b = (_a = response.headers.get("ETag")) == null ? void 0 : _a.replace(/"/g, "")) != null ? _b : "";
+        part.etag = etag;
+        part.uploaded = true;
+        uploadedChunks++;
+      } else {
+        part.uploaded = false;
+        const errorText = yield response.text();
+        console.error(`\u274C Failed to upload part ${part.number}: ${errorText}`);
+      }
+    } catch (err) {
+      part.uploaded = false;
+      console.error(`\u274C Error uploading part ${part.number}: ${err}`);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  });
+}
+function downloadPart(url) {
+  return __async(this, null, function* () {
+    const response = yield fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to download chunk: ${response.status}`);
+    }
+    const buffer = yield response.arrayBuffer();
+    return new Uint8Array(buffer);
+  });
+}
+
+// src/apis/management/file.factory.ts
+var File = class {
+  constructor(struct, _httpClient) {
+    this._httpClient = _httpClient;
+    this._id = struct._id;
+    this.meta = struct.meta;
+    this.folder = struct.folder;
+    this.ancestors = struct.ancestors;
+    this.original_title = struct.original_title;
+    this.file_type = struct.file_type;
+    this.size = struct.size;
+    this.total = struct.total;
+    this._httpClient = _httpClient;
+    if (this._httpClient.defaults["baseURL"] === void 0) {
+      console.error(`\u274C Can't retrieve requsted entity: Folder model can't find the management URL`);
+      throw new Error(`\u274C Can't retrieve requsted entity: Folder model can't find the management URL`);
+    }
+    this._managementURL = this._httpClient.defaults["baseURL"];
+    this._fileConsumer = new FileConsumer(this._httpClient);
+    this.download = withValidToken(
+      this.download.bind(this),
+      this._managementURL
+    );
+  }
+  getFilename() {
+    var _a;
+    const title = this.meta.title || "untitled";
+    const extension = ((_a = this.file_type) == null ? void 0 : _a.replace(/^\./, "")) || "";
+    if (extension && title.toLowerCase().endsWith(`.${extension.toLowerCase()}`)) {
+      return title;
+    }
+    console.log(title, extension);
+    return extension ? `${title}.${extension}` : title;
+  }
+  download(concurrencyLimit = 5, token) {
+    return __async(this, null, function* () {
+      if (this._id === void 0) {
+        throw new Error("No File ID found");
+      }
+      if (token === void 0) {
+        throw new Error("No token provided");
+      }
+      const wrapper = yield this._fileConsumer.initDownload(this._id, token);
+      const parts = wrapper.parts;
+      const results = yield runConcurrentWithResults(
+        parts,
+        (part) => downloadPart(part.presigned_url),
+        concurrencyLimit
+      );
+      const totalLength = results.reduce((acc, chunk) => acc + chunk.length, 0);
+      const merged = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of results) {
+        merged.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return merged;
+    });
+  }
+  // public list_items(token: string){
+  //     const params = new URLSearchParams({ id: this._id });
+  //     let config = {
+  //             params,
+  //             headers: {
+  //                 'Content-Type':'application/json',
+  //                 'Authorization': 'Bearer '  + token
+  //             }
+  //         }
+  //     return this._httpClient.get(this._managementURL + '/' + _namespace + '/list', config ).then(resp=>{
+  //         return resp.data
+  //     }).catch(error => {
+  //         console.error(`❌ Can't retrieve requsted entity:`, error);
+  //         return null; // Return null in case of failure
+  //     });
+  // }
+};
+
+// src/apis/management/file.consumer.ts
+var _namespace4 = "file";
+var FileConsumer = class extends BaseConsumer {
+  constructor(_httpClient) {
+    super(_httpClient, _namespace4);
+  }
+  getFileByID(id, token) {
+    return this.getOne(`/info/${id}`, null, token).then(
+      (resp) => {
+        return new File(resp, this._httpClient);
+      }
+    );
+  }
+  initUpload(file, fileSize, chunckSize, token) {
+    const config = {
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`,
+        "Chunk-Size": String(chunckSize),
+        "File-Size": String(fileSize)
+      }
+    };
+    return this._httpClient.post(this.path + "/upload/initialize", file, config).then((resp) => resp.data).catch((error) => {
+      console.error(`\u274C Error in posting:`, error);
+      return null;
+    });
+  }
+  closeUplaod(wrapper, token) {
+    return this.post("/upload/complete", wrapper, void 0, token);
+  }
+  initDownload(fileId, token) {
+    const config = {
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      timeout: 0
+      // disables timeout
+    };
+    return this._httpClient.get(this.path + `/download/initialize/${fileId}`, config).then((resp) => {
+      if (resp.data && resp.data.internal_status) {
+        console.error(`\u274C Error in response:`, resp.data.internal_status);
+        throw new Error("Download initialization failed: " + resp.data.internal_status);
+      }
+      return resp.data;
+    }).catch((error) => {
+      console.error(`\u274C Error in request:`, error);
+      throw new Error("Download initialization failed: " + error.message);
+    });
+  }
+  download(concurrent_limit = 5) {
+    return __async(this, null, function* () {
+      return new Blob();
+    });
+  }
+  store(_0) {
+    return __async(this, arguments, function* (path, concurrent_limit = 5, chunk_size = 5 * 1024 * 1024) {
+    });
+  }
+  rename(new_name) {
+    return __async(this, null, function* () {
+    });
+  }
+  changeType(new_type) {
+    return __async(this, null, function* () {
+    });
+  }
+  updateDescription(new_description) {
+    return __async(this, null, function* () {
+    });
+  }
+  // async copyTo(destination_name?: string, destination_id?: string, new_name?: string): Promise<IFile | null> {
+  //     // implement later
+  //     return null;
+  // }
+  moveTo(destination_name, destination_id, new_name) {
+    return __async(this, null, function* () {
+    });
+  }
+  // async delete(): Promise<boolean> {
+  //     // implement later
+  //     return false;
+  // }
+  checkRequestStatus() {
+    return __async(this, null, function* () {
+      return null;
+    });
+  }
+};
+
+// src/apis/management/folder.factory.ts
+var _namespace5 = "folder";
+var Folder = class {
+  constructor(struct, _httpClient) {
+    this._httpClient = _httpClient;
+    this._id = struct._id;
+    this.meta = struct.meta;
+    this.parent = struct.parent;
+    this.ancestors = struct.ancestors;
+    this.files = struct.files;
+    this.folders = struct.folders;
+    this.level = struct.level;
+    this.size = struct.size;
+    this._httpClient = _httpClient;
+    if (this._httpClient.defaults["baseURL"] === void 0) {
+      console.error(`\u274C Can't retrieve requsted entity: Folder model can't find the management URL`);
+      throw new Error(`\u274C Can't retrieve requsted entity: Folder model can't find the management URL`);
+    }
+    this._managementURL = this._httpClient.defaults["baseURL"];
+    this._fileConsumer = new FileConsumer(this._httpClient);
+    this.listItems = withValidToken(this.listItems.bind(this), this._managementURL);
+    this.getFileByID = withValidToken(this.getFileByID.bind(this), this._managementURL);
+    this.getFileByName = withValidToken(this.getFileByName.bind(this), this._managementURL);
+    this.uploadFile = withValidToken(
+      this.uploadFile.bind(this),
+      this._managementURL
+    );
+  }
+  getName() {
+    return this.meta.title;
+  }
+  listItems(token) {
+    const params = new URLSearchParams({ id: this._id });
+    let config = {
+      params,
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": "Bearer " + token
+      }
+    };
+    return this._httpClient.get(this._managementURL + "/" + _namespace5 + "/list", config).then((resp) => {
+      return resp.data;
+    }).catch((error) => {
+      console.error(`\u274C Can't retrieve requsted entity:`, error);
+      throw new Error(`\u274C Can't retrieve requsted entity: error`);
+    });
+  }
+  getFileByID(id, token) {
+    if (token === void 0) {
+      console.error(`\u274C Can't retrieve token`);
+      throw new Error(`\u274C Can't retrieve token`);
+    }
+    return this._fileConsumer.getFileByID(id, token);
+  }
+  getFileByName(name, token) {
+    if (token === void 0) {
+      console.error(`\u274C Can't retrieve token`);
+      throw new Error(`\u274C Can't retrieve token`);
+    }
+    return this.listItems(token).then(
+      (resp) => {
+        let fileInfo = resp.files.find((file) => file.meta.title === name);
+        if (fileInfo !== void 0) {
+          return new File(fileInfo, this._httpClient);
+        }
+        console.error(`\u274C File "${name}" does not exist in folder`);
+        throw new Error(`File "${name}" not found`);
+      }
+    );
+  }
+  uploadFile(_0, _1) {
+    return __async(this, arguments, function* (file, meta, chunkSize = 5 * 1024 * 1024, concurrentLimit = 10, timeout = 3600, token, onProgress) {
+      if (!this._id) throw new Error("Folder ID is missing in the current folder context");
+      if (!token) throw new Error("Token required for upload");
+      const fileSize = file.size;
+      const originalTitle = file.name.substring(0, file.name.lastIndexOf(".")) || file.name;
+      const fileType = file.name.includes(".") ? file.name.substring(file.name.lastIndexOf(".")) : "";
+      const totalChunks = Math.ceil(fileSize / chunkSize);
+      const fileModel = {
+        folder: this._id,
+        original_title: originalTitle,
+        file_type: fileType,
+        size: fileSize,
+        total: totalChunks,
+        meta
+      };
+      const wrapper = yield this._fileConsumer.initUpload(fileModel, fileSize, chunkSize, token);
+      const chunks = splitFileIntoChunks(file, chunkSize);
+      const uploadFn = createChunkUploader(chunks, timeout);
+      yield runConcurrent(wrapper.parts, uploadFn, concurrentLimit);
+      const allUploaded = wrapper.parts.every((p) => p.uploaded);
+      if (!allUploaded) {
+        throw new Error("Not all parts were uploaded successfully. Cannot complete upload.");
+      }
+      const finalModel = yield this._fileConsumer.closeUplaod(wrapper, token);
+      return new File(finalModel, this._httpClient);
+    });
+  }
+  // public uploadFile(
+  //         file: File,
+  //         meta: Meta,
+  //         chunkSize: number = 5 * 1024 * 1024,
+  //         concurrentLimit: number = 10,
+  //         timeout: number = 3600,
+  //         token?: string
+  //     ): Promise<FileModel> {
+  //     if (!token) {
+  //         throw new Error("Not token available");
+  //     }
+  //     const fileSize = file.size;
+  //     const originalTitle = file.name.substring(0, file.name.lastIndexOf(".")) || file.name;
+  //     const fileType = file.name.includes(".")
+  //         ? file.name.substring(file.name.lastIndexOf("."))
+  //         : "";
+  //     const totalChunks = Math.ceil(fileSize / chunkSize);
+  //     const fileModel: FileModel = {
+  //         folder: this._id,
+  //         original_title: originalTitle,
+  //         file_type: fileType,
+  //         size: fileSize,
+  //         total: totalChunks,
+  //         meta: meta,
+  //     };
+  //     return this._fileConsumer.initUpload(
+  //         fileModel,
+  //         fileSize,
+  //         chunkSize,
+  //         token
+  //     ).then(
+  //         (wrapper: MultipartWrapper) => {
+  //             const chunks = splitFileIntoChunks(file, chunkSize);
+  //             const uploadFn = createChunkUploader(chunks, timeout);
+  //             // ⬇ Upload all parts in parallel with concurrency limit and part mutation
+  //             runConcurrent(wrapper.parts, uploadFn, concurrentLimit).then(() => 
+  //                 {
+  //                     const allUploaded = wrapper.parts.every(p => p.uploaded);
+  //                     if (!allUploaded) {
+  //                         throw new Error("Not all parts were uploaded successfully. Cannot complete upload.");
+  //                     }
+  //                     this._fileConsumer.closeMultipart(this._managementURL, wrapper, token).then(
+  //                         (fileModel: FileModel) => {
+  //                             return new FileWrapper(fileModel, this._httpClient)
+  //                         }
+  //                     )
+  //                 }
+  //             )
+  //         }
+  //     );
+  // }
+};
+
+// src/apis/management/folder.consumer.ts
+var _namespace6 = "folder";
+var FolderConsumer = class extends BaseConsumer {
+  constructor(_httpClient) {
+    super(_httpClient, _namespace6);
+  }
+  getFolderByID(id, token) {
+    const params = id ? new URLSearchParams({ id }) : void 0;
+    return this.getOne("", params, token).then(
+      (resp) => {
+        return new Folder(resp, this._httpClient);
+      }
+    );
+  }
+  getFolderByName(name, token) {
+    const params = name ? new URLSearchParams({ path: name }) : void 0;
+    return this.getOne("", params, token).then(
+      (resp) => {
+        return new Folder(resp, this._httpClient);
+      }
+    );
+  }
+};
+
+// src/client.ts
+var Client = class {
+  constructor(_managementURL, _accountURL) {
+    const configManagement = {
+      baseURL: _managementURL
+    };
+    const configAccount = {
+      baseURL: _accountURL
+    };
+    const axiosManagement = import_axios.default.create(configManagement);
+    const axiosAccount = import_axios.default.create(configAccount);
+    this._userConsumer = new UserConsumer(axiosAccount);
+    this._groupConsumer = new GroupConsumer(axiosAccount);
+    this._bucketConsumer = new BucketConsumer(axiosManagement);
+    this._folderConsumer = new FolderConsumer(axiosManagement);
+    this.addToOrganization = withValidToken(this.addToOrganization.bind(this), _accountURL);
+    this.myUser = withValidToken(this.myUser.bind(this), _accountURL);
+    this.removeOrganizationByID = withValidToken(this.removeOrganizationByID.bind(this), _accountURL);
+    this.organizationByName = withValidToken(this.organizationByName.bind(this), _accountURL);
+    this.allOrganizations = withValidToken(this.allOrganizations.bind(this), _accountURL);
+    this.myOrganizations = withValidToken(this.myOrganizations.bind(this), _accountURL);
+    this.organizationByID = withValidToken(this.organizationByID.bind(this), _accountURL);
+    this.createOrganization = withValidToken(this.createOrganization.bind(this), _accountURL);
+    this.getFolderByName = withValidToken(this.getFolderByName.bind(this), _accountURL);
+    this.getFolderByID = withValidToken(this.getFolderByID.bind(this), _accountURL);
+  }
+  // public setSession(session: OidcToken): void {
+  //   const storage = typeof window !== "undefined" ? sessionStorage : global.sessionStorage;
+  //   if (storage) {
+  //       storage.setItem('token', session.access_token);
+  //       storage.setItem('refresh_token', session.refresh_token);
+  //       storage.setItem('exp', String(session.expires_in));
+  //       storage.setItem('refresh_exp', String(session.refresh_expires_in));
+  //   } else {
+  //       console.warn("Session storage is not available.");
+  //   }
+  // }
+  // public getSessionVariable(key: string): string | null {
+  //     const storage = typeof window !== "undefined" ? sessionStorage : global.sessionStorage;
+  //     return storage ? storage.getItem(key) : null;
+  // }
+  _setSession(session) {
+    const now = Math.floor(Date.now() / 1e3);
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem("token", session.access_token);
+      localStorage.setItem("refresh_token", session.refresh_token);
+      localStorage.setItem("exp", String(now + session.expires_in));
+      localStorage.setItem("refresh_exp", String(now + session.refresh_expires_in));
+    } else {
+      console.warn("\u26A0\uFE0F Local Storage not available. You will need to pass tokens manually.");
+    }
+  }
+  login(email, password) {
+    return this._userConsumer.login(email, password).then(
+      (resp) => {
+        this._setSession(resp);
+        return resp;
+      }
+    );
+  }
+  myUser(token) {
+    return this._userConsumer.getUser(token);
+  }
+  allOrganizations(token) {
+    return this._groupConsumer.getAllGroups(token);
+  }
+  myOrganizations(token) {
+    return this._groupConsumer.getUserGroups(token);
+  }
+  organizationByID(id, token) {
+    return this._groupConsumer.getGroupByID(id, token);
+  }
+  organizationByName(name, token) {
+    return this._groupConsumer.getGroupByName(name, token);
+  }
+  createOrganization(name, token) {
+    return this._groupConsumer.postGroup(name, token).then(
+      (group) => {
+        return this._bucketConsumer.postBucket(group.id, name, token);
+      }
+    );
+  }
+  removeOrganizationByID(organization, token) {
+    return this._groupConsumer.deleteGroup(organization, token).then(
+      () => {
+        return this._bucketConsumer.deleteBucket(organization, token).then(
+          (bucket) => {
+            if (!bucket) {
+              throw new Error(`Bucket with ID ${organization} could not be deleted.`);
+            }
+            return bucket;
+          }
+        );
+      }
+    );
+  }
+  addToOrganization(organization, users, token) {
+    return this._groupConsumer.addUsers(organization, users, token);
+  }
+  register(email, password, password_confirm, firstName, lastName) {
+    if (password != password_confirm) {
+      throw new Error("Passwords do not match");
+    }
+    return this._userConsumer.register(email, password, firstName, lastName);
+  }
+  getFolderByName(name, token) {
+    return this._folderConsumer.getFolderByName(name, token);
+  }
+  getFolderByID(id, token) {
+    return this._folderConsumer.getFolderByID(id, token);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Client
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@singularlogic/coreplatts",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --dts --format cjs --out-dir dist",
+    "test": "mocha --require ts-node/register tests/*.test.ts",
+    "types": "tsc --emitDeclarationOnly",
+    "release": "npm run types && npm run build"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "description": "",
+  "dependencies": {
+    "axios": "^1.8.3"
+  },
+  "devDependencies": {
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.13.10",
+    "eslint": "^9.25.0",
+    "mocha": "^11.1.0",
+    "prettier": "^3.5.3",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3"
+  }
+}