@secrecy/lib 1.0.0-dev.9 → 1.0.0

package/{lib → dist}/PopupTools.d.ts

@@ -13,5 +13,5 @@ declare type Options = {
 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 extends unknown>(data: T): string;
+export declare function popupResponse<T>(data: T): string;
 export {};

package/dist/PopupTools.js

@@ -0,0 +1,212 @@
+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
+ */
+const defaultOptions = {
+  width: 700,
+  height: 520,
+  menubar: "no",
+  resizable: "yes",
+  location: "yes",
+  scrollbars: "no",
+  centered: true
+};
+let popupCount = 1;
+/**
+ * Return options converted to a string
+ *
+ * @param  {Object} options
+ * @return {String}
+ */
+
+function optionsToString(options) {
+  return Object.entries(options).map(_ref => {
+    let [k, v] = _ref;
+    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");
+  }
+
+  const result = _objectSpread({}, options);
+
+  const width = window.outerWidth - options.width;
+  const 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;
+
+  const form = document.createElement("form");
+  let win = null;
+  form.setAttribute("method", "post");
+  form.setAttribute("action", url);
+  form.setAttribute("target", name);
+  Object.keys(postData).forEach(function addFormItem(key) {
+    const 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) {
+  const popupName = name || defaultPopupName();
+  const popupOptions = optionsResolveCentered(Object.assign({}, defaultOptions, options));
+
+  const popupCallback = callback || function noop() {//
+  };
+
+  const optionsString = optionsToString(popupOptions);
+  const win = execute(url, popupName, optionsString);
+  let isMessageSent = false;
+  let interval;
+
+  function popupCallbackOnce(err, data) {
+    if (!isMessageSent) {
+      isMessageSent = true;
+      popupCallback(err, data);
+    }
+  }
+
+  function onMessage(message) {
+    const 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) {
+  const 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,"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"],"sources":["../src/PopupTools.ts"],"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"],"mappings":"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"}

package/dist/ZeusThunder.js

@@ -0,0 +1,79 @@
+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; }
+
+import { GraphQLError, Thunder } from "./zeus/index.js";
+
+const handleFetchResponse = response => {
+  if (!response.ok) {
+    return new Promise((_, reject) => {
+      response.text().then(text => {
+        try {
+          reject(JSON.parse(text));
+        } catch (err) {
+          reject(text);
+        }
+      }).catch(reject);
+    });
+  }
+
+  return response.json();
+};
+
+const apiFetch = (options, session) => async function (query, variables) {
+  if (variables === void 0) {
+    variables = {};
+  }
+
+  const fetchFunction = fetch;
+  let queryString = query;
+  const fetchOptions = options[1] || {};
+
+  if (fetchOptions.method && fetchOptions.method === "GET") {
+    queryString = encodeURIComponent(query);
+    return fetchFunction(options[0] + "?query=" + queryString, fetchOptions).then(handleFetchResponse).then(response => {
+      if (response.errors) {
+        throw new GraphQLError(response);
+      }
+
+      return response.data;
+    });
+  }
+
+  const headers = {
+    "content-type": "application/json",
+    "accept-language": navigator.language
+  };
+
+  if (session) {
+    headers["secrecy-session"] = session;
+  }
+
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), 20000);
+  const res = await fetchFunction("" + options[0], _objectSpread({
+    body: JSON.stringify({
+      query: queryString,
+      variables
+    }),
+    method: "POST",
+    headers,
+    signal: controller.signal
+  }, fetchOptions)).then(handleFetchResponse).then(response => {
+    if (response.errors) {
+      throw new GraphQLError(response);
+    }
+
+    return response.data;
+  });
+  clearTimeout(id);
+  return res;
+};
+
+export const createThunder = (url, session) => 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,6 @@
+import type { InternalNode, InternalFile, InternalNodeFull } from "./client/types/index.js";
+export declare const filesCache: Map<string, InternalFile>;
+export declare const nodesCache: Map<string, InternalNode | InternalNodeFull>;
+export declare const usersCache: Map<string, import("./BaseClient.js").UserBase | (import("./BaseClient.js").UserBase & {
+    publicKey: string;
+})>;

package/dist/cache.js

@@ -0,0 +1,4 @@
+export const filesCache = new Map();
+export const nodesCache = new Map();
+export const usersCache = new Map();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmaWxlc0NhY2hlIiwiTWFwIiwibm9kZXNDYWNoZSIsInVzZXJzQ2FjaGUiXSwic291cmNlcyI6WyIuLi9zcmMvY2FjaGUudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBVc2VyIH0gZnJvbSBcIi4vaW5kZXguanNcIjtcbmltcG9ydCB0eXBlIHtcbiAgSW50ZXJuYWxOb2RlLFxuICBJbnRlcm5hbEZpbGUsXG4gIEludGVybmFsTm9kZUZ1bGxcbn0gZnJvbSBcIi4vY2xpZW50L3R5cGVzL2luZGV4LmpzXCI7XG5cbmV4cG9ydCBjb25zdCBmaWxlc0NhY2hlID0gbmV3IE1hcDxzdHJpbmcsIEludGVybmFsRmlsZT4oKTtcblxuZXhwb3J0IGNvbnN0IG5vZGVzQ2FjaGUgPSBuZXcgTWFwPHN0cmluZywgSW50ZXJuYWxOb2RlIHwgSW50ZXJuYWxOb2RlRnVsbD4oKTtcblxuZXhwb3J0IGNvbnN0IHVzZXJzQ2FjaGUgPSBuZXcgTWFwPFxuICBzdHJpbmcsXG4gIFVzZXIgfCBVc2VyPHsgd2l0aFB1YmxpY0tleTogdHJ1ZSB9PlxuPigpO1xuIl0sIm1hcHBpbmdzIjoiQUFPQSxPQUFPLE1BQU1BLFVBQVUsR0FBRyxJQUFJQyxHQUFKLEVBQW5CO0FBRVAsT0FBTyxNQUFNQyxVQUFVLEdBQUcsSUFBSUQsR0FBSixFQUFuQjtBQUVQLE9BQU8sTUFBTUUsVUFBVSxHQUFHLElBQUlGLEdBQUosRUFBbkIifQ==

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,110 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { storeBuddy } from "../../utils/store-buddy.js";
+import { BaseClient } from "../../BaseClient.js";
+const userSelector = {
+  id: true,
+  firstname: true,
+  lastname: true,
+  lang: true,
+  email: true,
+  phone: true,
+  role: true,
+  deletedAt: true,
+  lastLogin: true
+};
+export class AdminSecrecyClient extends BaseClient {
+  async userList(search) {
+    const {
+      userList
+    } = await this.client("query", {
+      scalars: {
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        }
+      }
+    })({
+      userList: [{
+        search
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on UserListResponse": {
+          __typename: true,
+          userList: userSelector
+        }
+      }]
+    });
+
+    if (!userList) {
+      return null;
+    }
+
+    if (userList.__typename === "ErrorAccessDenied") {
+      return userList;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: userList.userList
+    };
+  }
+
+  async changeUserPlan(userId, plan) {
+    const {
+      changeUserPlan
+    } = await this.client("mutation", {
+      scalars: {
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        }
+      }
+    })({
+      changeUserPlan: [{
+        userId,
+        plan
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ChangeUserPlanResponse": {
+          __typename: true,
+          changeUserPlan: userSelector
+        }
+      }]
+    });
+
+    if (!changeUserPlan) {
+      return null;
+    }
+
+    if (changeUserPlan.__typename === "ErrorAccessDenied") {
+      return changeUserPlan;
+    }
+
+    if (!changeUserPlan.changeUserPlan) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: changeUserPlan.changeUserPlan
+    };
+  }
+
+}
+export function getSecrecyAdminClient(env, session) {
+  const userSession = storeBuddy("secrecy.user_session", session).init("");
+  const uaSession = userSession.load();
+
+  if (uaSession === "") {
+    return null;
+  }
+
+  return new AdminSecrecyClient(uaSession, env);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["storeBuddy","BaseClient","userSelector","id","firstname","lastname","lang","email","phone","role","deletedAt","lastLogin","AdminSecrecyClient","userList","search","client","scalars","DateTime","decode","e","Date","encode","toISOString","__typename","message","data","changeUserPlan","userId","plan","getSecrecyAdminClient","env","session","userSession","init","uaSession","load"],"sources":["../../../src/client/admin/index.ts"],"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      scalars: {\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        }\n      }\n    })({\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    return {\n      __typename: \"SuccessResponse\",\n      data: userList.userList\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      scalars: {\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        }\n      }\n    })({\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: changeUserPlan.changeUserPlan\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"],"mappings":"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"}

package/{lib → dist}/client/convert/file.d.ts

@@ -1,5 +1,5 @@
 import type { KeyPair } from "../../crypto/index.js";
-import type { GQLFile, InternalFile, File } from "../types/index.js";
+import type { GQLFile, InternalFile, FileMetadata } 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;
+export declare function internalFileToFile(internal: InternalFile): FileMetadata;
+export declare function gqlFileToExternal(gql: GQLFile, keyPair: KeyPair): FileMetadata;

package/dist/client/convert/file.js

@@ -0,0 +1,34 @@
+import { filesCache } from "../../cache.js";
+import { decryptCryptoBox } from "../../crypto/index.js";
+import { sodium } from "../../sodium.js";
+export function gqlFileToInternal(gql, keyPair) {
+  if (!gql.access || !gql.access.sharedBy.keyPair) {
+    throw "File " + gql.id + " doesn't have access";
+  }
+
+  const file = {
+    id: gql.id,
+    md5: gql.md5,
+    md5Encrypted: gql.md5Encrypted,
+    createdAt: new Date(gql.createdAt),
+    size: BigInt(gql.size),
+    sizeBefore: BigInt(gql.sizeBefore),
+    key: sodium.to_hex(decryptCryptoBox(sodium.from_hex(gql.access.key), gql.access.sharedBy.keyPair.pub, keyPair.privateKey))
+  };
+  filesCache.set(file.id, file);
+  return file;
+}
+export function internalFileToFile(internal) {
+  return {
+    id: internal.id,
+    md5: internal.md5,
+    md5Encrypted: internal.md5Encrypted,
+    createdAt: internal.createdAt,
+    size: internal.size,
+    sizeBefore: internal.sizeBefore
+  };
+}
+export function gqlFileToExternal(gql, keyPair) {
+  return internalFileToFile(gqlFileToInternal(gql, keyPair));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/client/convert/mail.js

@@ -0,0 +1,46 @@
+import { sodium, decryptCryptoBox } from "../../index.js";
+export function convertInternalMailToExternal(data, keys) {
+  var _mI$replyTo;
+
+  if (data.mailIntegrityDraft) {
+    data.type = "draft";
+  }
+
+  const mI = data.type === "draft" ? data.mailIntegrityDraft : data.mailIntegrity;
+
+  if (!mI) {
+    return null;
+  }
+
+  const pubKey = data.type === "received" ? data.sender.publicKey : keys.publicKey;
+  const body = sodium.to_string(decryptCryptoBox(sodium.from_hex(data.body), pubKey, keys.privateKey));
+  const subject = sodium.to_string(decryptCryptoBox(sodium.from_hex(data.subject), pubKey, keys.privateKey));
+  const hash = sodium.crypto_generichash(sodium.crypto_generichash_BYTES, JSON.stringify({
+    body,
+    subject
+  }), mI.hashKey, "hex");
+  return {
+    type: data.type,
+    id: data.id,
+    mailIntegrityId: mI.id,
+    replyTo: (_mI$replyTo = mI.replyTo) == null ? void 0 : _mI$replyTo.id,
+    body,
+    subject,
+    createdAt: new Date(data.createdAt),
+    deletedAt: data.deletedAt ? new Date(data.deletedAt) : null,
+    openedAt: data.openedAt ? new Date(data.openedAt) : null,
+    isAltered: hash !== mI.hash,
+    temporaryRecipients: mI.temporaryRecipients,
+    recipients: data.type === "draft" ? mI.recipients : data.recipients,
+    sender: data.sender,
+    files: data.files.map(f => {
+      const name = sodium.to_string(decryptCryptoBox(sodium.from_hex(f.filename), pubKey, keys.privateKey));
+      return {
+        id: f.file.id,
+        name,
+        key: f.fileKey
+      };
+    })
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,9 @@
+import type { KeyPair } from "../../crypto/index.js";
+import type { Node } from "../types/index.js";
+import type { GQLNode, InternalNode, GQLNodeFull, InternalNodeFull, NodeFull } from "../types/index.js";
+export declare function gqlNodeToInternal(gql: GQLNode, keyPair: KeyPair): Promise<InternalNode>;
+export declare function gqlNodeFullToInternalFull(gql: GQLNodeFull, keyPair: KeyPair): Promise<InternalNodeFull>;
+export declare function internalNodeToNode(internal: InternalNode): Node;
+export declare function internalNodeFullToNodeFull(internal: InternalNodeFull): NodeFull;
+export declare function gqlNodeToExternalNodeFull(gql: GQLNodeFull, keyPair: KeyPair): Promise<NodeFull>;
+export declare function gqlNodeToExternal(gql: GQLNode, keyPair: KeyPair): Promise<Node>;