@secrecy/lib 1.0.0-dev.27 → 1.0.0-dev.28

package/dist/PopupTools.d.ts

@@ -0,0 +1,17 @@
+declare type YesNo = "yes" | "no";
+declare type Options = {
+    width?: number;
+    height?: number;
+    menubar: YesNo;
+    resizable: YesNo;
+    location: YesNo;
+    scrollbars: YesNo;
+    centered?: boolean;
+    left?: number;
+    top?: number;
+};
+declare type Callback = (err?: Error, data?: unknown) => void;
+export declare function popup(url: string, name: string, options: Partial<Options>, callback: Callback): Window | null;
+export declare function popupWithPost(url: string, postData: Record<string, string>, name: string, options: Partial<Options>, callback: Callback): Window | null;
+export declare function popupResponse<T>(data: T): string;
+export {};

package/dist/PopupTools.js

@@ -0,0 +1,213 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+/**
+ * TS Rewrite of https://github.com/enhancv/popup-tools
+ */
+var defaultOptions = {
+  width: 700,
+  height: 520,
+  menubar: "no",
+  resizable: "yes",
+  location: "yes",
+  scrollbars: "no",
+  centered: true
+};
+var popupCount = 1;
+/**
+ * Return options converted to a string
+ *
+ * @param  {Object} options
+ * @return {String}
+ */
+
+function optionsToString(options) {
+  return Object.entries(options).map(function (_ref) {
+    var k = _ref[0],
+        v = _ref[1];
+    return k + "=" + v;
+  }).join(",");
+}
+/**
+ * Get a unique name on each call
+ * @return {String}
+ */
+
+
+function defaultPopupName() {
+  popupCount += 1;
+  return "Popup " + popupCount;
+}
+/**
+ * Convert "centered: true" key into concrete left and top arguments
+ * Both can be overwritten
+ *
+ * @param  {Object} options
+ * @return {Object}
+ */
+
+
+function optionsResolveCentered(options) {
+  if (!options.width || !options.height) {
+    throw new Error("Should have width and height");
+  }
+
+  var result = _objectSpread({}, options);
+
+  var width = window.outerWidth - options.width;
+  var height = window.outerHeight - options.height;
+
+  if (options.centered) {
+    result.left = options.left || Math.round(window.screenX + width / 2);
+    result.top = options.top || Math.round(window.screenY + height / 2.5);
+    delete result.centered;
+  }
+
+  return result;
+}
+/**
+ * Create a form element, add hidden inputs for all the post data
+ * and post it into a newly opened popup
+ *
+ * @param  {String} url
+ * @param  {Object} postData
+ * @param  {String} name
+ * @param  {Object} options
+ * @return {Object}
+ */
+
+
+function openPopupWithPost(url, postData, name, options) {
+  var _win;
+
+  var form = document.createElement("form");
+  var win = null;
+  form.setAttribute("method", "post");
+  form.setAttribute("action", url);
+  form.setAttribute("target", name);
+  Object.keys(postData).forEach(function addFormItem(key) {
+    var input = document.createElement("input");
+    input.type = "hidden";
+    input.name = key;
+    input.value = postData[key];
+    form.appendChild(input);
+  });
+  document.body.appendChild(form);
+  win = window.open("/", name, options);
+  (_win = win) == null ? void 0 : _win.document.write("Loading...");
+  form.submit();
+  document.body.removeChild(form);
+  return win;
+}
+/**
+ * Open a popup using the first argument. Wait for it to close.
+ * Returns the window object
+ *
+ * @param  {Function}
+ * @param  {String}
+ * @param  {String}
+ * @param  {Object}
+ * @param  {Function}
+ * @return {Object}
+ */
+
+
+function popupExecute(execute, url, name, options, callback) {
+  var popupName = name || defaultPopupName();
+  var popupOptions = optionsResolveCentered(Object.assign({}, defaultOptions, options));
+
+  var popupCallback = callback || function noop() {//
+  };
+
+  var optionsString = optionsToString(popupOptions);
+  var win = execute(url, popupName, optionsString);
+  var isMessageSent = false;
+  var interval;
+
+  function popupCallbackOnce(err, data) {
+    if (!isMessageSent) {
+      isMessageSent = true;
+      popupCallback(err, data);
+    }
+  }
+
+  function onMessage(message) {
+    var data = message ? message.data : undefined;
+
+    if (data) {
+      popupCallbackOnce(undefined, data);
+      window.removeEventListener("message", onMessage);
+    }
+  }
+
+  window.addEventListener("message", onMessage, false);
+
+  if (win) {
+    interval = window.setInterval(function closePopupCallback() {
+      if (win === null || win.closed) {
+        setTimeout(function delayWindowClosing() {
+          clearInterval(interval);
+          popupCallbackOnce(new Error("Popup closed"));
+        }, 500);
+      }
+    }, 100);
+  } else {
+    popupCallbackOnce(new Error("Popup blocked"));
+  }
+
+  return win;
+}
+/**
+ * Open a popup using the first argument.
+ * Wait for it to close and call the callback.
+ * Set the options string using the options object
+ * Returns the window object
+ *
+ * @param  {String} url
+ * @param  {String} name
+ * @param  {Object} options
+ * @param  {Function} callback
+ * @return {Object}
+ */
+
+
+export function popup(url, name, options, callback) {
+  return popupExecute(window.open, url, name, options, callback);
+}
+/**
+ * Open a popup using the first argument.
+ * Post the data into the open popup.
+ * Wait for it to close and call the callback.
+ * Set the options string using the options object
+ * Returns the window object
+ *
+ * @param  {String} url
+ * @param  {Object} postData
+ * @param  {String} name
+ * @param  {Object} options
+ * @param  {Function} callback
+ * @return {Object}
+ */
+
+export function popupWithPost(url, postData, name, options, callback) {
+  function openWithPostData(popupUrl, popupName, optionsString) {
+    return openPopupWithPost(popupUrl, postData, popupName, optionsString);
+  }
+
+  return popupExecute(openWithPostData, url, name, options, callback);
+}
+/**
+ * Return html that when executed, will trigger the popup to callback with a response
+ *
+ * @param  {Object}
+ * @return {String}
+ */
+
+export function popupResponse(data) {
+  var jsonData = JSON.stringify(data);
+  return "<script>window.opener.postMessage(" + jsonData + ", \"*\");setTimeout(function() { window.close(); }, 50);</script>";
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/PopupTools.ts"],"names":["defaultOptions","width","height","menubar","resizable","location","scrollbars","centered","popupCount","optionsToString","options","Object","entries","map","k","v","join","defaultPopupName","optionsResolveCentered","Error","result","window","outerWidth","outerHeight","left","Math","round","screenX","top","screenY","openPopupWithPost","url","postData","name","form","document","createElement","win","setAttribute","keys","forEach","addFormItem","key","input","type","value","appendChild","body","open","write","submit","removeChild","popupExecute","execute","callback","popupName","popupOptions","assign","popupCallback","noop","optionsString","isMessageSent","interval","popupCallbackOnce","err","data","onMessage","message","undefined","removeEventListener","addEventListener","setInterval","closePopupCallback","closed","setTimeout","delayWindowClosing","clearInterval","popup","popupWithPost","openWithPostData","popupUrl","popupResponse","jsonData","JSON","stringify"],"mappings":"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","sourcesContent":["/**\n * TS Rewrite of https://github.com/enhancv/popup-tools\n */\n\ntype YesNo = \"yes\" | \"no\";\ntype Options = {\n  width?: number;\n  height?: number;\n  menubar: YesNo;\n  resizable: YesNo;\n  location: YesNo;\n  scrollbars: YesNo;\n  centered?: boolean;\n  left?: number;\n  top?: number;\n};\n\nconst defaultOptions: Options = {\n  width: 700,\n  height: 520,\n  menubar: \"no\",\n  resizable: \"yes\",\n  location: \"yes\",\n  scrollbars: \"no\",\n  centered: true\n};\n\ntype Callback = (err?: Error, data?: unknown) => void;\n\ntype WindowOpen = (\n  popupUrl: string,\n  popupName: string,\n  optionsString: string\n) => Window | null;\n\nlet popupCount = 1;\n\n/**\n * Return options converted to a string\n *\n * @param  {Object} options\n * @return {String}\n */\nfunction optionsToString<T extends Options>(options: T): string {\n  return Object.entries(options)\n    .map(([k, v]) => `${k}=${v}`)\n    .join(\",\");\n}\n\n/**\n * Get a unique name on each call\n * @return {String}\n */\nfunction defaultPopupName(): string {\n  popupCount += 1;\n  return `Popup ${popupCount}`;\n}\n\n/**\n * Convert \"centered: true\" key into concrete left and top arguments\n * Both can be overwritten\n *\n * @param  {Object} options\n * @return {Object}\n */\nfunction optionsResolveCentered(options: Options): Options {\n  if (!options.width || !options.height) {\n    throw new Error(\"Should have width and height\");\n  }\n  const result = { ...options };\n  const width = window.outerWidth - options.width;\n  const height = window.outerHeight - options.height;\n\n  if (options.centered) {\n    result.left = options.left || Math.round(window.screenX + width / 2);\n    result.top = options.top || Math.round(window.screenY + height / 2.5);\n    delete result.centered;\n  }\n  return result;\n}\n\n/**\n * Create a form element, add hidden inputs for all the post data\n * and post it into a newly opened popup\n *\n * @param  {String} url\n * @param  {Object} postData\n * @param  {String} name\n * @param  {Object} options\n * @return {Object}\n */\nfunction openPopupWithPost(\n  url: string,\n  postData: Record<string, string>,\n  name: string,\n  options: string\n): Window | null {\n  const form = document.createElement(\"form\");\n  let win: Window | null = null;\n\n  form.setAttribute(\"method\", \"post\");\n  form.setAttribute(\"action\", url);\n  form.setAttribute(\"target\", name);\n\n  Object.keys(postData).forEach(function addFormItem(key) {\n    const input = document.createElement(\"input\");\n    input.type = \"hidden\";\n    input.name = key;\n    input.value = postData[key];\n    form.appendChild(input);\n  });\n\n  document.body.appendChild(form);\n\n  win = window.open(\"/\", name, options);\n  win?.document.write(\"Loading...\");\n\n  form.submit();\n  document.body.removeChild(form);\n\n  return win;\n}\n\n/**\n * Open a popup using the first argument. Wait for it to close.\n * Returns the window object\n *\n * @param  {Function}\n * @param  {String}\n * @param  {String}\n * @param  {Object}\n * @param  {Function}\n * @return {Object}\n */\nfunction popupExecute(\n  execute: WindowOpen,\n  url: string,\n  name: string,\n  options: Partial<Options>,\n  callback: Callback\n): Window | null {\n  const popupName = name || defaultPopupName();\n  const popupOptions = optionsResolveCentered(\n    Object.assign({}, defaultOptions, options)\n  );\n  const popupCallback =\n    callback ||\n    function noop(): void {\n      //\n    };\n  const optionsString = optionsToString(popupOptions);\n  const win = execute(url, popupName, optionsString);\n  let isMessageSent = false;\n  let interval: number;\n\n  function popupCallbackOnce(err?: Error, data?: unknown): void {\n    if (!isMessageSent) {\n      isMessageSent = true;\n      popupCallback(err, data);\n    }\n  }\n\n  function onMessage(message?: MessageEvent): void {\n    const data = message ? message.data : undefined;\n\n    if (data) {\n      popupCallbackOnce(undefined, data);\n      window.removeEventListener(\"message\", onMessage);\n    }\n  }\n\n  window.addEventListener(\"message\", onMessage, false);\n\n  if (win) {\n    interval = window.setInterval(function closePopupCallback() {\n      if (win === null || win.closed) {\n        setTimeout(function delayWindowClosing() {\n          clearInterval(interval);\n          popupCallbackOnce(new Error(\"Popup closed\"));\n        }, 500);\n      }\n    }, 100);\n  } else {\n    popupCallbackOnce(new Error(\"Popup blocked\"));\n  }\n\n  return win;\n}\n\n/**\n * Open a popup using the first argument.\n * Wait for it to close and call the callback.\n * Set the options string using the options object\n * Returns the window object\n *\n * @param  {String} url\n * @param  {String} name\n * @param  {Object} options\n * @param  {Function} callback\n * @return {Object}\n */\nexport function popup(\n  url: string,\n  name: string,\n  options: Partial<Options>,\n  callback: Callback\n): Window | null {\n  return popupExecute(window.open, url, name, options, callback);\n}\n\n/**\n * Open a popup using the first argument.\n * Post the data into the open popup.\n * Wait for it to close and call the callback.\n * Set the options string using the options object\n * Returns the window object\n *\n * @param  {String} url\n * @param  {Object} postData\n * @param  {String} name\n * @param  {Object} options\n * @param  {Function} callback\n * @return {Object}\n */\nexport function popupWithPost(\n  url: string,\n  postData: Record<string, string>,\n  name: string,\n  options: Partial<Options>,\n  callback: Callback\n): Window | null {\n  function openWithPostData(\n    popupUrl: string,\n    popupName: string,\n    optionsString: string\n  ): Window | null {\n    return openPopupWithPost(popupUrl, postData, popupName, optionsString);\n  }\n\n  return popupExecute(openWithPostData, url, name, options, callback);\n}\n\n/**\n * Return html that when executed, will trigger the popup to callback with a response\n *\n * @param  {Object}\n * @return {String}\n */\nexport function popupResponse<T>(data: T): string {\n  const jsonData = JSON.stringify(data);\n\n  return `<script>window.opener.postMessage(${jsonData}, \"*\");setTimeout(function() { window.close(); }, 50);</script>`;\n}\n"]}

package/dist/ZeusThunder.d.ts

@@ -0,0 +1,2 @@
+import { Thunder } from "./zeus/index.js";
+export declare const createThunder: (url: string, session?: string | null | undefined) => ReturnType<typeof Thunder>;

package/dist/ZeusThunder.js

@@ -0,0 +1,113 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { GraphQLError, Thunder } from "./zeus/index.js";
+
+var handleFetchResponse = function handleFetchResponse(response) {
+  if (!response.ok) {
+    return new Promise(function (_, reject) {
+      response.text().then(function (text) {
+        try {
+          reject(JSON.parse(text));
+        } catch (err) {
+          reject(text);
+        }
+      }).catch(reject);
+    });
+  }
+
+  return response.json();
+};
+
+var apiFetch = function apiFetch(options, session) {
+  return /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(query, variables) {
+      var fetchFunction, queryString, fetchOptions, headers, controller, id, res;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (variables === void 0) {
+                variables = {};
+              }
+
+              fetchFunction = fetch;
+              queryString = query;
+              fetchOptions = options[1] || {};
+
+              if (!(fetchOptions.method && fetchOptions.method === "GET")) {
+                _context.next = 7;
+                break;
+              }
+
+              queryString = encodeURIComponent(query);
+              return _context.abrupt("return", fetchFunction(options[0] + "?query=" + queryString, fetchOptions).then(handleFetchResponse).then(function (response) {
+                if (response.errors) {
+                  throw new GraphQLError(response);
+                }
+
+                return response.data;
+              }));
+
+            case 7:
+              headers = {
+                "content-type": "application/json",
+                "accept-language": navigator.language
+              };
+
+              if (session) {
+                headers["secrecy-session"] = session;
+              }
+
+              controller = new AbortController();
+              id = setTimeout(function () {
+                return controller.abort();
+              }, 20000);
+              _context.next = 13;
+              return fetchFunction("" + options[0], _objectSpread({
+                body: JSON.stringify({
+                  query: queryString,
+                  variables: variables
+                }),
+                method: "POST",
+                headers: headers,
+                signal: controller.signal
+              }, fetchOptions)).then(handleFetchResponse).then(function (response) {
+                if (response.errors) {
+                  throw new GraphQLError(response);
+                }
+
+                return response.data;
+              });
+
+            case 13:
+              res = _context.sent;
+              clearTimeout(id);
+              return _context.abrupt("return", res);
+
+            case 16:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+
+export var createThunder = function createThunder(url, session) {
+  return Thunder(apiFetch([url, {
+    mode: "cors",
+    credentials: "same-origin"
+  }], session));
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/cache.d.ts

@@ -0,0 +1,7 @@
+import type { InternalVFile, InternalFolder, InternalVFileWithFolder, InternalFile, InternalFolderFull } from "./client/types/index.js";
+export declare const vFilesCache: Map<string, InternalVFile | InternalVFileWithFolder>;
+export declare const filesCache: Map<string, InternalFile>;
+export declare const foldersCache: Map<string, InternalFolder | InternalFolderFull>;
+export declare const usersCache: Map<string, import("./BaseClient.js").UserBase | (import("./BaseClient.js").UserBase & {
+    publicKey: string;
+})>;

package/dist/cache.js

@@ -0,0 +1,5 @@
+export var vFilesCache = new Map();
+export var filesCache = new Map();
+export var foldersCache = new Map();
+export var usersCache = new Map();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9jYWNoZS50cyJdLCJuYW1lcyI6WyJ2RmlsZXNDYWNoZSIsIk1hcCIsImZpbGVzQ2FjaGUiLCJmb2xkZXJzQ2FjaGUiLCJ1c2Vyc0NhY2hlIl0sIm1hcHBpbmdzIjoiQUFTQSxPQUFPLElBQU1BLFdBQVcsR0FBRyxJQUFJQyxHQUFKLEVBQXBCO0FBS1AsT0FBTyxJQUFNQyxVQUFVLEdBQUcsSUFBSUQsR0FBSixFQUFuQjtBQUVQLE9BQU8sSUFBTUUsWUFBWSxHQUFHLElBQUlGLEdBQUosRUFBckI7QUFLUCxPQUFPLElBQU1HLFVBQVUsR0FBRyxJQUFJSCxHQUFKLEVBQW5CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBVc2VyIH0gZnJvbSBcIi4vaW5kZXguanNcIjtcbmltcG9ydCB0eXBlIHtcbiAgSW50ZXJuYWxWRmlsZSxcbiAgSW50ZXJuYWxGb2xkZXIsXG4gIEludGVybmFsVkZpbGVXaXRoRm9sZGVyLFxuICBJbnRlcm5hbEZpbGUsXG4gIEludGVybmFsRm9sZGVyRnVsbFxufSBmcm9tIFwiLi9jbGllbnQvdHlwZXMvaW5kZXguanNcIjtcblxuZXhwb3J0IGNvbnN0IHZGaWxlc0NhY2hlID0gbmV3IE1hcDxcbiAgc3RyaW5nLFxuICBJbnRlcm5hbFZGaWxlIHwgSW50ZXJuYWxWRmlsZVdpdGhGb2xkZXJcbj4oKTtcblxuZXhwb3J0IGNvbnN0IGZpbGVzQ2FjaGUgPSBuZXcgTWFwPHN0cmluZywgSW50ZXJuYWxGaWxlPigpO1xuXG5leHBvcnQgY29uc3QgZm9sZGVyc0NhY2hlID0gbmV3IE1hcDxcbiAgc3RyaW5nLFxuICBJbnRlcm5hbEZvbGRlciB8IEludGVybmFsRm9sZGVyRnVsbFxuPigpO1xuXG5leHBvcnQgY29uc3QgdXNlcnNDYWNoZSA9IG5ldyBNYXA8XG4gIHN0cmluZyxcbiAgVXNlciB8IFVzZXI8eyB3aXRoUHVibGljS2V5OiB0cnVlIH0+XG4+KCk7XG4iXX0=

package/dist/client/admin/index.d.ts

@@ -0,0 +1,11 @@
+import type { PlanKind, SecrecyEnv, SuccessResponse, User } from "../../index.js";
+import { BaseClient } from "../../BaseClient.js";
+import type { ErrorAccessDenied } from "../../error.js";
+export declare type UserAdminPanel = User<{
+    withPublicKey: false;
+}>;
+export declare class AdminSecrecyClient extends BaseClient {
+    userList(search?: string | null | undefined): Promise<SuccessResponse<UserAdminPanel[]> | ErrorAccessDenied | null>;
+    changeUserPlan(userId: string, plan: PlanKind): Promise<SuccessResponse<UserAdminPanel> | ErrorAccessDenied | null>;
+}
+export declare function getSecrecyAdminClient(env: SecrecyEnv, session?: boolean | undefined): AdminSecrecyClient | null;

package/dist/client/admin/index.js

@@ -0,0 +1,198 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+/* eslint-disable @typescript-eslint/naming-convention */
+import { storeBuddy } from "../../utils/store-buddy.js";
+import { BaseClient } from "../../BaseClient.js";
+var userSelector = {
+  id: true,
+  firstname: true,
+  lastname: true,
+  lang: true,
+  email: true,
+  phone: true,
+  role: true,
+  deletedAt: true,
+  lastLogin: true
+};
+export var AdminSecrecyClient = /*#__PURE__*/function (_BaseClient) {
+  _inheritsLoose(AdminSecrecyClient, _BaseClient);
+
+  function AdminSecrecyClient() {
+    return _BaseClient.apply(this, arguments) || this;
+  }
+
+  var _proto = AdminSecrecyClient.prototype;
+
+  _proto.userList = /*#__PURE__*/function () {
+    var _userList = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(search) {
+      var _yield$this$client, userList, result;
+
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this.client("query")({
+                userList: [{
+                  search: search
+                }, {
+                  "...on ErrorAccessDenied": {
+                    __typename: true,
+                    message: true
+                  },
+                  "...on UserListResponse": {
+                    __typename: true,
+                    userList: userSelector
+                  }
+                }]
+              });
+
+            case 2:
+              _yield$this$client = _context.sent;
+              userList = _yield$this$client.userList;
+
+              if (userList) {
+                _context.next = 6;
+                break;
+              }
+
+              return _context.abrupt("return", null);
+
+            case 6:
+              if (!(userList.__typename === "ErrorAccessDenied")) {
+                _context.next = 8;
+                break;
+              }
+
+              return _context.abrupt("return", userList);
+
+            case 8:
+              result = userList.userList.map(function (user) {
+                return _objectSpread(_objectSpread({}, user), {}, {
+                  lastLogin: new Date(user.lastLogin),
+                  deletedAt: user.deletedAt ? new Date(user.deletedAt) : null
+                });
+              });
+              return _context.abrupt("return", {
+                __typename: "SuccessResponse",
+                data: result
+              });
+
+            case 10:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function userList(_x) {
+      return _userList.apply(this, arguments);
+    }
+
+    return userList;
+  }();
+
+  _proto.changeUserPlan = /*#__PURE__*/function () {
+    var _changeUserPlan = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(userId, plan) {
+      var _yield$this$client2, changeUserPlan;
+
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this.client("mutation")({
+                changeUserPlan: [{
+                  userId: userId,
+                  plan: plan
+                }, {
+                  "...on ErrorAccessDenied": {
+                    __typename: true,
+                    message: true
+                  },
+                  "...on ChangeUserPlanResponse": {
+                    __typename: true,
+                    changeUserPlan: userSelector
+                  }
+                }]
+              });
+
+            case 2:
+              _yield$this$client2 = _context2.sent;
+              changeUserPlan = _yield$this$client2.changeUserPlan;
+
+              if (changeUserPlan) {
+                _context2.next = 6;
+                break;
+              }
+
+              return _context2.abrupt("return", null);
+
+            case 6:
+              if (!(changeUserPlan.__typename === "ErrorAccessDenied")) {
+                _context2.next = 8;
+                break;
+              }
+
+              return _context2.abrupt("return", changeUserPlan);
+
+            case 8:
+              if (changeUserPlan.changeUserPlan) {
+                _context2.next = 10;
+                break;
+              }
+
+              return _context2.abrupt("return", null);
+
+            case 10:
+              return _context2.abrupt("return", {
+                __typename: "SuccessResponse",
+                data: {
+                  deletedAt: changeUserPlan.changeUserPlan.deletedAt ? new Date(changeUserPlan.changeUserPlan.deletedAt) : null,
+                  lastLogin: new Date(changeUserPlan.changeUserPlan.lastLogin),
+                  email: changeUserPlan.changeUserPlan.email,
+                  firstname: changeUserPlan.changeUserPlan.firstname,
+                  id: changeUserPlan.changeUserPlan.id,
+                  lang: changeUserPlan.changeUserPlan.lang,
+                  lastname: changeUserPlan.changeUserPlan.lastname,
+                  phone: changeUserPlan.changeUserPlan.phone,
+                  role: changeUserPlan.changeUserPlan.role
+                }
+              });
+
+            case 11:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function changeUserPlan(_x2, _x3) {
+      return _changeUserPlan.apply(this, arguments);
+    }
+
+    return changeUserPlan;
+  }();
+
+  return AdminSecrecyClient;
+}(BaseClient);
+export function getSecrecyAdminClient(env, session) {
+  var userSession = storeBuddy("secrecy.user_session", session).init("");
+  var uaSession = userSession.load();
+
+  if (uaSession === "") {
+    return null;
+  }
+
+  return new AdminSecrecyClient(uaSession, env);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/client/admin/index.ts"],"names":["storeBuddy","BaseClient","userSelector","id","firstname","lastname","lang","email","phone","role","deletedAt","lastLogin","AdminSecrecyClient","userList","search","client","__typename","message","result","map","user","Date","data","changeUserPlan","userId","plan","getSecrecyAdminClient","env","session","userSession","init","uaSession","load"],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/naming-convention */\nimport type {\n  PlanKind,\n  SecrecyEnv,\n  SuccessResponse,\n  User\n} from \"../../index.js\";\nimport { storeBuddy } from \"../../utils/store-buddy.js\";\nimport { BaseClient } from \"../../BaseClient.js\";\nimport type { ErrorAccessDenied } from \"../../error.js\";\n\n/* TODO\n- query pour lister les users avec pagination et input optionnel \"search\" et boolean pour filtrer les bans\n- mutation changer le plan d'un user (sans payer du coup)\n- query pour renvoyer les apps d'un user\n- query pour donner les limites d'un user\n- query pour donner les reports d'un user\n- mutation pour ban un user\n- query pour get les bans d'un user\n- mutation pour delete un user (déjà existant?)\n- mutation changer le role du user (user/admin)\n- mutation pour déco une ou des sessions meta ou app d'un user\n- query afficher les sessions meta ou app d'un user\n- query pour afficher des infos sur le cloud d'un user\n- mutation pour delete, restore, delete trash, dans le cloud d'un user\n- query pour afficher les infos sur les mails d'un user\n- mutation pour delete, restore, delete trash, dans les mails d'un user\n- query pour afficher les limites max et actuels d'un user\n- query de stats?\n*/\n\nexport type UserAdminPanel = User<{ withPublicKey: false }>;\nconst userSelector = {\n  id: true,\n  firstname: true,\n  lastname: true,\n  lang: true,\n  email: true,\n  phone: true,\n  role: true,\n  deletedAt: true,\n  lastLogin: true\n} as const;\n\nexport class AdminSecrecyClient extends BaseClient {\n  async userList(\n    search?: string | null | undefined\n  ): Promise<SuccessResponse<UserAdminPanel[]> | ErrorAccessDenied | null> {\n    const { userList } = await this.client(\"query\")({\n      userList: [\n        {\n          search\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on UserListResponse\": {\n            __typename: true,\n            userList: userSelector\n          }\n        }\n      ]\n    });\n\n    if (!userList) {\n      return null;\n    }\n\n    if (userList.__typename === \"ErrorAccessDenied\") {\n      return userList;\n    }\n\n    const result = userList.userList.map(user => ({\n      ...user,\n      lastLogin: new Date(user.lastLogin),\n      deletedAt: user.deletedAt ? new Date(user.deletedAt) : null\n    }));\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: result\n    };\n  }\n\n  async changeUserPlan(\n    userId: string,\n    plan: PlanKind\n  ): Promise<SuccessResponse<UserAdminPanel> | ErrorAccessDenied | null> {\n    const { changeUserPlan } = await this.client(\"mutation\")({\n      changeUserPlan: [\n        {\n          userId,\n          plan\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ChangeUserPlanResponse\": {\n            __typename: true,\n            changeUserPlan: userSelector\n          }\n        }\n      ]\n    });\n\n    if (!changeUserPlan) {\n      return null;\n    }\n\n    if (changeUserPlan.__typename === \"ErrorAccessDenied\") {\n      return changeUserPlan;\n    }\n\n    if (!changeUserPlan.changeUserPlan) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: {\n        deletedAt: changeUserPlan.changeUserPlan.deletedAt\n          ? new Date(changeUserPlan.changeUserPlan.deletedAt)\n          : null,\n        lastLogin: new Date(changeUserPlan.changeUserPlan.lastLogin),\n        email: changeUserPlan.changeUserPlan.email,\n        firstname: changeUserPlan.changeUserPlan.firstname,\n        id: changeUserPlan.changeUserPlan.id,\n        lang: changeUserPlan.changeUserPlan.lang,\n        lastname: changeUserPlan.changeUserPlan.lastname,\n        phone: changeUserPlan.changeUserPlan.phone,\n        role: changeUserPlan.changeUserPlan.role\n      }\n    };\n  }\n}\n\nexport function getSecrecyAdminClient(\n  env: SecrecyEnv,\n  session?: boolean | undefined\n): AdminSecrecyClient | null {\n  const userSession = storeBuddy<string>(`secrecy.user_session`, session).init(\n    \"\"\n  );\n  const uaSession = userSession.load();\n  if (uaSession === \"\") {\n    return null;\n  }\n\n  return new AdminSecrecyClient(uaSession, env);\n}\n"]}

package/dist/client/convert/file.d.ts

@@ -0,0 +1,5 @@
+import type { KeyPair } from "../../crypto/index.js";
+import type { GQLFile, InternalFile, File } from "../types/index.js";
+export declare function gqlFileToInternal(gql: GQLFile, keyPair: KeyPair): InternalFile;
+export declare function internalFileToFile(internal: InternalFile): File;
+export declare function gqlFileToExternal(gql: GQLFile, keyPair: KeyPair): File;