@secrecy/lib 1.0.0-dev.8 → 1.0.0-dev.81

package/dist/client/SecrecyPayClient.d.ts

@@ -0,0 +1,28 @@
+import type { SecrecyClient, SecrecyEnv } from "../index.js";
+import type { KeyPair } from "../crypto/index.js";
+import type { Thunder } from "../zeus/index.js";
+declare type SuccessPayResponse<T> = {
+    success: true;
+    data: T;
+};
+declare type ErrorPayResponse = {
+    success: false;
+    error: string;
+};
+export declare type SecrecyPayResponse<T> = SuccessPayResponse<T> | ErrorPayResponse;
+export declare class SecrecyPayClient {
+    #private;
+    constructor(client: SecrecyClient, keys: KeyPair, thunder: ReturnType<typeof Thunder>);
+    confirmPaymentIntent({ env, paymentIntentId, secrecyIdWhoCreatedPaymentIntent, secrecyIdWhoNeedToConfirmPaymentIntent, amount, currency }: {
+        env?: SecrecyEnv;
+        paymentIntentId: string;
+        secrecyIdWhoCreatedPaymentIntent: string;
+        secrecyIdWhoNeedToConfirmPaymentIntent: string;
+        amount: number;
+        currency: "eur" | "usd";
+    }): Promise<SecrecyPayResponse<{
+        id: string;
+        message: string;
+    }>>;
+}
+export {};

package/dist/client/SecrecyPayClient.js

@@ -0,0 +1,68 @@
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/classPrivateFieldLooseKey";
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import { getUrl } from "../index.js";
+import { popup } from "../PopupTools.js";
+var _client = /*#__PURE__*/_classPrivateFieldLooseKey("client");
+var _keys = /*#__PURE__*/_classPrivateFieldLooseKey("keys");
+var _thunder = /*#__PURE__*/_classPrivateFieldLooseKey("thunder");
+export class SecrecyPayClient {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+
+  constructor(client, keys, thunder) {
+    Object.defineProperty(this, _client, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _keys, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _thunder, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _client)[_client] = client;
+    _classPrivateFieldLooseBase(this, _keys)[_keys] = keys;
+    _classPrivateFieldLooseBase(this, _thunder)[_thunder] = thunder;
+  }
+  async confirmPaymentIntent(_ref) {
+    let {
+      env = "prod",
+      paymentIntentId,
+      secrecyIdWhoCreatedPaymentIntent,
+      secrecyIdWhoNeedToConfirmPaymentIntent,
+      amount,
+      currency
+    } = _ref;
+    const url = getUrl({
+      env,
+      hash: Buffer.from(JSON.stringify({
+        appSession: _classPrivateFieldLooseBase(this, _client)[_client].sessionId,
+        paymentIntentId,
+        secrecyIdWhoCreatedPaymentIntent,
+        secrecyIdWhoNeedToConfirmPaymentIntent,
+        amount,
+        currency
+      })).toString("base64"),
+      path: "/account/iframe/pay-confirm"
+    });
+    return new Promise((resolve, reject) => popup(url, "Secrecy Pay - Confirm Payment Intent", {
+      width: 500
+    }, (err, data) => {
+      if (err) {
+        return reject(err);
+      }
+      return resolve(data);
+    }));
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/client/SecrecyWalletClient.d.ts

@@ -0,0 +1,30 @@
+import type { SecrecyClient, SecrecyEnv } from "../index.js";
+import { InfuraNetwork } from "../zeus/index.js";
+import type { providers } from "ethers";
+declare type SuccessWalletResponse<T> = {
+    success: true;
+    data: T;
+};
+declare type ErrorWalletResponse = {
+    success: false;
+    error: string;
+};
+export declare type SecrecyWalletResponse<T> = SuccessWalletResponse<T> | ErrorWalletResponse;
+export declare class SecrecyWalletClient {
+    #private;
+    constructor(client: SecrecyClient);
+    createTransaction({ env, network, tx }: {
+        env?: SecrecyEnv;
+        network?: InfuraNetwork;
+        tx: providers.TransactionRequest;
+    }): Promise<SecrecyWalletResponse<{
+        id: string;
+        hash: string;
+    }>>;
+    createSignature({ env, network, message }: {
+        env?: SecrecyEnv;
+        network?: InfuraNetwork;
+        message: string;
+    }): Promise<SecrecyWalletResponse<string>>;
+}
+export {};

package/dist/client/SecrecyWalletClient.js

@@ -0,0 +1,73 @@
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/classPrivateFieldLooseKey";
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import { getUrl } from "../index.js";
+import { InfuraNetwork } from "../zeus/index.js";
+import { popup } from "../PopupTools.js";
+var _client = /*#__PURE__*/_classPrivateFieldLooseKey("client");
+export class SecrecyWalletClient {
+  // #keys: KeyPair;
+
+  // #thunder: ReturnType<typeof Thunder>;
+
+  constructor(client) {
+    Object.defineProperty(this, _client, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _client)[_client] = client;
+    // this.#keys = keys;
+    // this.#thunder = thunder;
+  }
+
+  async createTransaction(_ref) {
+    let {
+      env = "prod",
+      network = InfuraNetwork.mainnet,
+      tx
+    } = _ref;
+    const url = getUrl({
+      env,
+      hash: Buffer.from(JSON.stringify({
+        appSession: _classPrivateFieldLooseBase(this, _client)[_client].sessionId,
+        network,
+        tx
+      })).toString("base64"),
+      path: "/account/iframe/wallet-transaction"
+    });
+    return new Promise((resolve, reject) => popup(url, "Secrecy Wallet - Transaction", {
+      width: 500
+    }, (err, data) => {
+      if (err) {
+        return reject(err);
+      }
+      return resolve(data);
+    }));
+  }
+  async createSignature(_ref2) {
+    let {
+      env = "prod",
+      network = InfuraNetwork.mainnet,
+      message
+    } = _ref2;
+    const url = getUrl({
+      env,
+      hash: Buffer.from(JSON.stringify({
+        appSession: _classPrivateFieldLooseBase(this, _client)[_client].sessionId,
+        network,
+        message
+      })).toString("base64"),
+      path: "/account/iframe/wallet-signature"
+    });
+    return new Promise((resolve, reject) => popup(url, "Secrecy Wallet - Signature", {
+      width: 500
+    }, (err, data) => {
+      if (err) {
+        return reject(err);
+      }
+      return resolve(data);
+    }));
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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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,33 @@
+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.d.ts

@@ -0,0 +1,3 @@
+import type { KeyPair } from "../../crypto/index.js";
+import type { GQLMail, Mail } from "../types/index.js";
+export declare function convertInternalMailToExternal(data: GQLMail, keys: KeyPair): Mail | null;

package/dist/client/convert/mail.js

@@ -0,0 +1,43 @@
+import { sodium, decryptCryptoBox } from "../../index.js";
+export function convertInternalMailToExternal(data, keys) {
+  var _mI$replyTo;
+  let type = data.type;
+  if (data.mailIntegrityDraft) {
+    type = "draft";
+  }
+  const mI = 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,
+    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: 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>;

package/dist/client/convert/node.js

@@ -0,0 +1,88 @@
+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 { sodium } from "../../sodium.js";
+import { decryptCryptoBox } from "../../crypto/index.js";
+import { nodesCache } from "../../cache.js";
+import { decryptSecretstream } from "../../crypto/file.js";
+import { gqlFileToInternal, internalFileToFile } from "./file.js";
+export async function gqlNodeToInternal(gql, keyPair) {
+  if (!gql.access) {
+    throw `Can't access Node ${gql.id}`;
+  }
+  const internal = {
+    id: gql.id,
+    type: gql.type,
+    access: gql.access,
+    name: gql.name,
+    isFavorite: gql.isFavorite,
+    breadcrumb: gql.breadcrumb,
+    createdBy: gql.createdBy.user,
+    sizes: {
+      size: BigInt(gql.sizes.size),
+      sizeBefore: BigInt(gql.sizes.sizeBefore)
+    },
+    createdAt: new Date(gql.createdAt),
+    updatedAt: new Date(gql.updatedAt),
+    deletedAt: gql.deletedAt ? new Date(gql.deletedAt) : null,
+    users: gql.accesses.map(u => [u.userApp.user, u.rights]),
+    parentId: gql.parentId ?? null,
+    currentFileId: gql.currentFileId ?? null
+  };
+  internal.access = _objectSpread({}, gql.access);
+  if (gql.access.nameKey) {
+    if (!gql.access.sharedBy.keyPair) {
+      throw new Error(`Can't find keyPair for access`);
+    }
+    const key = decryptCryptoBox(sodium.from_hex(gql.access.nameKey), gql.createdBy.user.publicKey, keyPair.privateKey);
+    internal.name = sodium.to_string(await decryptSecretstream(key, sodium.from_hex(internal.name)));
+    internal.access.nameKey = sodium.to_hex(key);
+  }
+  for (const b of internal.breadcrumb) {
+    if (!b.nameKey) {
+      continue;
+    }
+    const key = decryptCryptoBox(sodium.from_hex(b.nameKey), b.pubKey, keyPair.privateKey);
+    b.nameKey = sodium.to_hex(key);
+    b.name = sodium.to_string(await decryptSecretstream(key, sodium.from_hex(b.name)));
+  }
+  nodesCache.set(internal.id, internal);
+  return internal;
+}
+export async function gqlNodeFullToInternalFull(gql, keyPair) {
+  const f = await gqlNodeToInternal(gql, keyPair);
+  return _objectSpread(_objectSpread({}, f), {}, {
+    current: gql.current ? gqlFileToInternal(gql.current, keyPair) : undefined,
+    parent: gql.parent ? await gqlNodeToInternal(gql.parent, keyPair) : null,
+    children: await Promise.all(gql.children.map(s => gqlNodeToInternal(s, keyPair))),
+    history: gql.history.map(f => gqlFileToInternal(f, keyPair))
+  });
+}
+export function internalNodeToNode(internal) {
+  var _node$access;
+  const node = _objectSpread(_objectSpread({}, internal), {}, {
+    access: internal.access ? _objectSpread({}, internal.access) : undefined
+  });
+  for (const b of node.breadcrumb) {
+    // @ts-ignore
+    delete b.pubKey;
+  }
+  // @ts-ignore
+  (_node$access = node.access) == null ? true : delete _node$access.nameKey;
+  return node;
+}
+export function internalNodeFullToNodeFull(internal) {
+  return _objectSpread(_objectSpread({}, internalNodeToNode(internal)), {}, {
+    parent: internal.parent ? internalNodeToNode(internal.parent) : null,
+    children: internal.children.map(internalNodeToNode),
+    history: internal.history.map(f => internalFileToFile(f)),
+    current: internal.current ? internalFileToFile(internal.current) : undefined
+  });
+}
+export async function gqlNodeToExternalNodeFull(gql, keyPair) {
+  return internalNodeFullToNodeFull(await gqlNodeFullToInternalFull(gql, keyPair));
+}
+export async function gqlNodeToExternal(gql, keyPair) {
+  return internalNodeToNode(await gqlNodeToInternal(gql, keyPair));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["sodium","decryptCryptoBox","nodesCache","decryptSecretstream","gqlFileToInternal","internalFileToFile","gqlNodeToInternal","gql","keyPair","access","id","internal","type","name","isFavorite","breadcrumb","createdBy","user","sizes","size","BigInt","sizeBefore","createdAt","Date","updatedAt","deletedAt","users","accesses","map","u","userApp","rights","parentId","currentFileId","nameKey","sharedBy","Error","key","from_hex","publicKey","privateKey","to_string","to_hex","b","pubKey","set","gqlNodeFullToInternalFull","f","current","undefined","parent","children","Promise","all","s","history","internalNodeToNode","node","internalNodeFullToNodeFull","gqlNodeToExternalNodeFull","gqlNodeToExternal"],"sources":["../../../src/client/convert/node.ts"],"sourcesContent":["import { sodium } from \"../../sodium.js\";\nimport type { KeyPair } from \"../../crypto/index.js\";\nimport { decryptCryptoBox } from \"../../crypto/index.js\";\nimport type { Node } from \"../types/index.js\";\nimport type {\n  GQLNode,\n  InternalNode,\n  GQLNodeFull,\n  InternalNodeFull,\n  NodeFull\n} from \"../types/index.js\";\nimport { nodesCache } from \"../../cache.js\";\nimport { decryptSecretstream } from \"../../crypto/file.js\";\nimport { gqlFileToInternal, internalFileToFile } from \"./file.js\";\n\nexport async function gqlNodeToInternal(\n  gql: GQLNode,\n  keyPair: KeyPair\n): Promise<InternalNode> {\n  if (!gql.access) {\n    throw `Can't access Node ${gql.id}`;\n  }\n\n  const internal: InternalNode = {\n    id: gql.id,\n    type: gql.type,\n    access: gql.access,\n    name: gql.name,\n    isFavorite: gql.isFavorite,\n    breadcrumb: gql.breadcrumb,\n    createdBy: gql.createdBy.user,\n    sizes: {\n      size: BigInt(gql.sizes.size as string),\n      sizeBefore: BigInt(gql.sizes.sizeBefore as string)\n    },\n    createdAt: new Date(gql.createdAt as string),\n    updatedAt: new Date(gql.updatedAt as string),\n    deletedAt: gql.deletedAt ? new Date(gql.deletedAt as string) : null,\n    users: gql.accesses.map(u => [u.userApp.user, u.rights]),\n    parentId: gql.parentId ?? null,\n    currentFileId: gql.currentFileId ?? null\n  };\n\n  internal.access = { ...gql.access };\n\n  if (gql.access.nameKey) {\n    if (!gql.access.sharedBy.keyPair) {\n      throw new Error(`Can't find keyPair for access`);\n    }\n    const key = decryptCryptoBox(\n      sodium.from_hex(gql.access.nameKey),\n      gql.createdBy.user.publicKey,\n      keyPair.privateKey\n    );\n    internal.name = sodium.to_string(\n      await decryptSecretstream(key, sodium.from_hex(internal.name))\n    );\n\n    internal.access.nameKey = sodium.to_hex(key);\n  }\n\n  for (const b of internal.breadcrumb) {\n    if (!b.nameKey) {\n      continue;\n    }\n    const key = decryptCryptoBox(\n      sodium.from_hex(b.nameKey),\n      b.pubKey,\n      keyPair.privateKey\n    );\n\n    b.nameKey = sodium.to_hex(key);\n\n    b.name = sodium.to_string(\n      await decryptSecretstream(key, sodium.from_hex(b.name))\n    );\n  }\n\n  nodesCache.set(internal.id, internal);\n  return internal;\n}\n\nexport async function gqlNodeFullToInternalFull(\n  gql: GQLNodeFull,\n  keyPair: KeyPair\n): Promise<InternalNodeFull> {\n  const f = await gqlNodeToInternal(gql, keyPair);\n  return {\n    ...f,\n    current: gql.current ? gqlFileToInternal(gql.current, keyPair) : undefined,\n    parent: gql.parent ? await gqlNodeToInternal(gql.parent, keyPair) : null,\n    children: await Promise.all(\n      gql.children.map(s => gqlNodeToInternal(s, keyPair))\n    ),\n    history: gql.history.map(f => gqlFileToInternal(f, keyPair))\n  };\n}\n\nexport function internalNodeToNode(internal: InternalNode): Node {\n  const node: Node = {\n    ...internal,\n    access: internal.access ? { ...internal.access } : undefined\n  };\n\n  for (const b of node.breadcrumb) {\n    // @ts-ignore\n    delete b.pubKey;\n  }\n  // @ts-ignore\n  delete node.access?.nameKey;\n  return node;\n}\n\nexport function internalNodeFullToNodeFull(\n  internal: InternalNodeFull\n): NodeFull {\n  return {\n    ...internalNodeToNode(internal),\n    parent: internal.parent ? internalNodeToNode(internal.parent) : null,\n    children: internal.children.map(internalNodeToNode),\n    history: internal.history.map(f => internalFileToFile(f)),\n    current: internal.current ? internalFileToFile(internal.current) : undefined\n  };\n}\n\nexport async function gqlNodeToExternalNodeFull(\n  gql: GQLNodeFull,\n  keyPair: KeyPair\n): Promise<NodeFull> {\n  return internalNodeFullToNodeFull(\n    await gqlNodeFullToInternalFull(gql, keyPair)\n  );\n}\n\nexport async function gqlNodeToExternal(\n  gql: GQLNode,\n  keyPair: KeyPair\n): Promise<Node> {\n  return internalNodeToNode(await gqlNodeToInternal(gql, keyPair));\n}\n"],"mappings":"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"}

package/{lib → dist}/client/helpers.d.ts

@@ -1,6 +1,11 @@
 import { SecrecyClient } from "./index.js";
 import type { SecrecyUserApp } from "./types/index.js";
 export declare function parseInfos(): SecrecyUserApp | null;
+export declare const getUrl: ({ env, hash, path }: {
+    env: string;
+    hash: string;
+    path: string;
+}) => string;
 export declare type HashInfos = {
     appUrl: string;
     backPath?: string;
@@ -11,7 +16,7 @@ export declare type HashInfos = {
         email: boolean;
     };
 };
-export declare type SecrecyEnv = "dev" | "staging" | "prod";
+export declare type SecrecyEnv = "dev" | "prod";
 export declare type UseSecrecyParams = Omit<HashInfos, "appUrl"> & {
     env: SecrecyEnv;
     session?: boolean | undefined;

package/dist/client/helpers.js

@@ -0,0 +1,119 @@
+import { SecrecyClient } from "./index.js";
+import { popup } from "../PopupTools.js";
+import { getStorage } from "./storage.js";
+export function parseInfos() {
+  if (!window.location.hash) {
+    return null;
+  }
+  const hash = window.location.hash.substr(1);
+  try {
+    const res = JSON.parse(atob(hash));
+    window.location.hash = "";
+    // TODO Add object content validation
+    return res;
+  } catch {
+    return null;
+  }
+}
+export const getUrl = _ref => {
+  let {
+    env,
+    hash,
+    path
+  } = _ref;
+  let envStr = "";
+  if (env === "dev") {
+    envStr = "dev.";
+  }
+  const lang = document.documentElement.lang;
+  return process.env.NEXT_PUBLIC_SECRECY_API_URL ? `http://localhost:3002${lang ? `/${lang}` : ""}${path.startsWith("/") ? path : `/${path}`}#${hash}` : `https://auth.${envStr}secrecy.me${lang ? `/${lang}` : ""}${path.startsWith("/") ? path : `/${path}`}#${hash}`;
+};
+export function getSecrecyClient(env, session) {
+  const storage = getStorage(session);
+  const uaSession = storage.userAppSession.load();
+  const uaKeys = storage.userAppKeys.load();
+  const uaJwt = storage.jwt.load();
+  if (!uaSession || !uaKeys || !uaJwt) {
+    const infos = parseInfos();
+    if (infos) {
+      storage.userAppKeys.save(infos.keys);
+      storage.userAppSession.save(infos.uaSession);
+      storage.jwt.save(infos.jwt);
+      return new SecrecyClient(infos.uaSession, infos.keys, infos.jwt, env);
+    }
+    return null;
+  }
+  return new SecrecyClient(uaSession, uaKeys, uaJwt, env);
+}
+export function login(_temp) {
+  let {
+    appCode,
+    path,
+    redirect,
+    scopes,
+    backPath,
+    env,
+    session
+  } = _temp === void 0 ? {} : _temp;
+  return new Promise((resolve, reject) => {
+    const appUrl = window.location.origin;
+    if (appCode && !appUrl.includes("localhost")) {
+      return reject("Can't use appCode if not in localhost");
+    }
+    const client = getSecrecyClient(env);
+    if (!client) {
+      const infos = {
+        appUrl,
+        appCode,
+        redirect,
+        path,
+        scopes,
+        backPath
+      };
+      const data = btoa(JSON.stringify(infos)).replaceAll("=", "");
+      const url = getUrl({
+        env,
+        hash: data,
+        path: "login"
+      });
+      const validate = infos => {
+        const storage = getStorage(session);
+        storage.userAppSession.save(infos.uaSession);
+        storage.userAppKeys.save(infos.keys);
+        storage.jwt.save(infos.jwt);
+        return resolve(new SecrecyClient(infos.uaSession, infos.keys, infos.jwt, env));
+      };
+      if (redirect) {
+        const infos = parseInfos();
+        if (infos) {
+          return validate(infos);
+        } else {
+          window.location.href = url;
+          return resolve(null);
+        }
+      } else {
+        popup(url, "Secrecy Login", {
+          width: 500,
+          height: 750,
+          resizable: "no",
+          menubar: "no",
+          location: "no",
+          centered: true,
+          scrollbars: "no"
+        }, (err, data) => {
+          if (err) {
+            return reject(err);
+          } else {
+            const infos = data;
+            if (infos) {
+              return validate(infos);
+            }
+          }
+        });
+      }
+    } else {
+      return resolve(client);
+    }
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["SecrecyClient","popup","getStorage","parseInfos","window","location","hash","substr","res","JSON","parse","atob","getUrl","env","path","envStr","lang","document","documentElement","process","NEXT_PUBLIC_SECRECY_API_URL","startsWith","getSecrecyClient","session","storage","uaSession","userAppSession","load","uaKeys","userAppKeys","uaJwt","jwt","infos","save","keys","login","appCode","redirect","scopes","backPath","Promise","resolve","reject","appUrl","origin","includes","client","data","btoa","stringify","replaceAll","url","validate","href","width","height","resizable","menubar","centered","scrollbars","err"],"sources":["../../src/client/helpers.ts"],"sourcesContent":["import { SecrecyClient } from \"./index.js\";\nimport { popup } from \"../PopupTools.js\";\nimport type { SecrecyUserApp } from \"./types/index.js\";\nimport { getStorage } from \"./storage.js\";\n\nexport function parseInfos(): SecrecyUserApp | null {\n  if (!window.location.hash) {\n    return null;\n  }\n  const hash = window.location.hash.substr(1);\n  try {\n    const res = JSON.parse(atob(hash));\n    window.location.hash = \"\";\n    // TODO Add object content validation\n    return res;\n  } catch {\n    return null;\n  }\n}\n\nexport const getUrl = ({\n  env,\n  hash,\n  path\n}: {\n  env: string;\n  hash: string;\n  path: string;\n}): string => {\n  let envStr = \"\";\n  if (env === \"dev\") {\n    envStr = \"dev.\";\n  }\n  const lang = document.documentElement.lang;\n  return process.env.NEXT_PUBLIC_SECRECY_API_URL\n    ? `http://localhost:3002${lang ? `/${lang}` : \"\"}${\n        path.startsWith(\"/\") ? path : `/${path}`\n      }#${hash}`\n    : `https://auth.${envStr}secrecy.me${lang ? `/${lang}` : \"\"}${\n        path.startsWith(\"/\") ? path : `/${path}`\n      }#${hash}`;\n};\n\nexport type HashInfos = {\n  appUrl: string;\n  backPath?: string;\n  appCode?: string | null | undefined;\n  path?: string | null | undefined;\n  redirect?: boolean;\n  scopes?: {\n    email: boolean;\n  };\n};\nexport type SecrecyEnv = \"dev\" | \"prod\";\nexport type UseSecrecyParams = Omit<HashInfos, \"appUrl\"> & {\n  env: SecrecyEnv;\n  session?: boolean | undefined;\n};\n\nexport type Value<T extends UseSecrecyParams> = T extends { redirect: true }\n  ? SecrecyClient | null\n  : SecrecyClient;\n\nexport function getSecrecyClient(\n  env: SecrecyEnv,\n  session?: boolean | undefined\n): SecrecyClient | null {\n  const storage = getStorage(session);\n  const uaSession = storage.userAppSession.load();\n  const uaKeys = storage.userAppKeys.load();\n  const uaJwt = storage.jwt.load();\n  if (!uaSession || !uaKeys || !uaJwt) {\n    const infos = parseInfos();\n    if (infos) {\n      storage.userAppKeys.save(infos.keys);\n      storage.userAppSession.save(infos.uaSession);\n      storage.jwt.save(infos.jwt);\n      return new SecrecyClient(infos.uaSession, infos.keys, infos.jwt, env);\n    }\n    return null;\n  }\n\n  return new SecrecyClient(uaSession, uaKeys, uaJwt, env);\n}\n\nexport function login<T extends UseSecrecyParams>(\n  { appCode, path, redirect, scopes, backPath, env, session }: T = {} as T\n): Promise<Value<T>> {\n  return new Promise((resolve, reject) => {\n    const appUrl = window.location.origin;\n    if (appCode && !appUrl.includes(\"localhost\")) {\n      return reject(\"Can't use appCode if not in localhost\");\n    }\n    const client = getSecrecyClient(env);\n\n    if (!client) {\n      const infos: HashInfos = {\n        appUrl,\n        appCode,\n        redirect,\n        path,\n        scopes,\n        backPath\n      };\n      const data = btoa(JSON.stringify(infos)).replaceAll(\"=\", \"\");\n\n      const url = getUrl({\n        env,\n        hash: data,\n        path: \"login\"\n      });\n\n      const validate = (infos: SecrecyUserApp): void => {\n        const storage = getStorage(session);\n        storage.userAppSession.save(infos.uaSession);\n        storage.userAppKeys.save(infos.keys);\n        storage.jwt.save(infos.jwt);\n        return resolve(\n          new SecrecyClient(\n            infos.uaSession,\n            infos.keys,\n            infos.jwt,\n            env\n          ) as Value<T>\n        );\n      };\n\n      if (redirect) {\n        const infos = parseInfos();\n        if (infos) {\n          return validate(infos);\n        } else {\n          window.location.href = url;\n          return resolve(null as Value<T>);\n        }\n      } else {\n        popup(\n          url,\n          \"Secrecy Login\",\n          {\n            width: 500,\n            height: 750,\n            resizable: \"no\",\n            menubar: \"no\",\n            location: \"no\",\n            centered: true,\n            scrollbars: \"no\"\n          },\n          (err, data) => {\n            if (err) {\n              return reject(err);\n            } else {\n              const infos = data as SecrecyUserApp;\n              if (infos) {\n                return validate(infos);\n              }\n            }\n          }\n        );\n      }\n    } else {\n      return resolve(client as Value<T>);\n    }\n  });\n}\n"],"mappings":"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"}