@secrecy/lib 1.0.0-dev.54 → 1.0.0-dev.55

package/dist/client/SecrecyDbClient.d.ts

@@ -0,0 +1,21 @@
+import type { SecrecyClient, SuccessResponse, UserData } from "../index.js";
+import type { KeyPair } from "../crypto/index.js";
+import type { ErrorAccessDenied, ErrorBasic, ErrorNotExist, ErrorNotFound } from "../error.js";
+import type { Thunder } from "../zeus/index.js";
+import type { Document } from "bson";
+export declare class SecrecyDbClient {
+    #private;
+    constructor(_client: SecrecyClient, _keys: KeyPair, thunder: ReturnType<typeof Thunder>);
+    dbGet<U>({ field, userId }: {
+        field: string;
+        userId?: string | null | undefined;
+    }): Promise<SuccessResponse<U> | ErrorAccessDenied | ErrorNotExist | ErrorNotFound | null>;
+    dbSet<T extends UserData, U extends Document>({ value, userId }: {
+        value: U;
+        userId?: string | null | undefined;
+    }): Promise<SuccessResponse<T> | ErrorAccessDenied | ErrorNotFound | null>;
+    dbSearch<T>({ search, field }: {
+        field: string;
+        search: string;
+    }): Promise<SuccessResponse<T[]> | ErrorAccessDenied | ErrorBasic | ErrorNotExist | null>;
+}

package/dist/client/SecrecyDbClient.js

@@ -0,0 +1,198 @@
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/classPrivateFieldLooseKey";
+
+/* eslint-disable @typescript-eslint/naming-convention */
+import { serialize } from "bson";
+
+var _thunder = /*#__PURE__*/_classPrivateFieldLooseKey("thunder");
+
+export class SecrecyDbClient {
+  // #client: SecrecyClient;
+  // #keys: KeyPair;
+  constructor(_client, _keys, thunder) {
+    Object.defineProperty(this, _thunder, {
+      writable: true,
+      value: void 0
+    });
+    // this.#client = client;
+    // this.#keys = keys;
+    _classPrivateFieldLooseBase(this, _thunder)[_thunder] = thunder;
+  }
+
+  async dbGet(_ref) {
+    let {
+      field,
+      userId
+    } = _ref;
+    const {
+      dbGet
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("query")({
+      dbGet: [{
+        field,
+        userId
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotExist": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on DbGetResponse": {
+          __typename: true,
+          json: true
+        }
+      }]
+    });
+
+    if (!dbGet) {
+      return null;
+    }
+
+    if (dbGet.__typename === "ErrorAccessDenied") {
+      return dbGet;
+    }
+
+    if (dbGet.__typename === "ErrorNotExist") {
+      return dbGet;
+    }
+
+    if (dbGet.__typename === "ErrorNotFound") {
+      return dbGet;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: dbGet.json.res
+    };
+  }
+
+  async dbSet(_ref2) {
+    let {
+      value,
+      userId
+    } = _ref2;
+
+    if (typeof value !== "object") {
+      throw new Error("value should be an object including fields you want to update.");
+    }
+
+    const {
+      dbSet
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation")({
+      dbSet: [{
+        userId,
+        value: serialize(value).toString("base64")
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on DbSetResponse": {
+          __typename: true,
+          dbSet: true
+        }
+      }]
+    });
+
+    if (!dbSet) {
+      return null;
+    }
+
+    if (dbSet.__typename === "ErrorAccessDenied") {
+      return dbSet;
+    }
+
+    if (dbSet.__typename === "ErrorNotFound") {
+      return dbSet;
+    }
+
+    if (!dbSet.dbSet) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: dbSet.dbSet.res
+    };
+  }
+
+  async dbSearch(_ref3) {
+    let {
+      search,
+      field
+    } = _ref3;
+    const {
+      dbSearch
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("query", {
+      scalars: {
+        Json: {
+          encode: e => JSON.stringify(e),
+          decode: e => JSON.parse(e)
+        },
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        },
+        BigInt: {
+          decode: e => BigInt(e),
+          encode: e => e.toString()
+        }
+      }
+    })({
+      dbSearch: [{
+        search,
+        field
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorBasic": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotExist": {
+          __typename: true,
+          message: true
+        },
+        "...on DbSearchResponse": {
+          __typename: true,
+          json: true
+        }
+      }]
+    });
+
+    if (!dbSearch) {
+      return null;
+    }
+
+    if (dbSearch.__typename === "ErrorAccessDenied") {
+      return dbSearch;
+    }
+
+    if (dbSearch.__typename === "ErrorBasic") {
+      return dbSearch;
+    }
+
+    if (dbSearch.__typename === "ErrorNotExist") {
+      return dbSearch;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: dbSearch.json
+    };
+  }
+
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["serialize","SecrecyDbClient","constructor","_client","_keys","thunder","dbGet","field","userId","__typename","message","json","data","res","dbSet","value","Error","toString","dbSearch","search","scalars","Json","encode","e","JSON","stringify","decode","parse","DateTime","Date","toISOString","BigInt"],"sources":["../../src/client/SecrecyDbClient.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/naming-convention */\nimport type { SecrecyClient, SuccessResponse, UserData } from \"../index.js\";\nimport type { KeyPair } from \"../crypto/index.js\";\nimport type {\n  ErrorAccessDenied,\n  ErrorBasic,\n  ErrorNotExist,\n  ErrorNotFound\n} from \"../error.js\";\nimport type { Thunder } from \"../zeus/index.js\";\nimport type { Document } from \"bson\";\nimport { serialize } from \"bson\";\n\nexport class SecrecyDbClient {\n  // #client: SecrecyClient;\n\n  // #keys: KeyPair;\n\n  #thunder: ReturnType<typeof Thunder>;\n\n  constructor(\n    _client: SecrecyClient,\n    _keys: KeyPair,\n    thunder: ReturnType<typeof Thunder>\n  ) {\n    // this.#client = client;\n    // this.#keys = keys;\n    this.#thunder = thunder;\n  }\n\n  async dbGet<U>({\n    field,\n    userId\n  }: {\n    field: string;\n    userId?: string | null | undefined;\n  }): Promise<\n    | SuccessResponse<U>\n    | ErrorAccessDenied\n    | ErrorNotExist\n    | ErrorNotFound\n    | null\n  > {\n    const { dbGet } = await this.#thunder(\"query\")({\n      dbGet: [\n        {\n          field,\n          userId\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorNotExist\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on DbGetResponse\": {\n            __typename: true,\n            json: true\n          }\n        }\n      ]\n    });\n\n    if (!dbGet) {\n      return null;\n    }\n\n    if (dbGet.__typename === \"ErrorAccessDenied\") {\n      return dbGet;\n    }\n\n    if (dbGet.__typename === \"ErrorNotExist\") {\n      return dbGet;\n    }\n\n    if (dbGet.__typename === \"ErrorNotFound\") {\n      return dbGet;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: (dbGet.json as { res: U }).res\n    };\n  }\n\n  async dbSet<T extends UserData, U extends Document>({\n    value,\n    userId\n  }: {\n    value: U;\n    userId?: string | null | undefined;\n  }): Promise<SuccessResponse<T> | ErrorAccessDenied | ErrorNotFound | null> {\n    if (typeof value !== \"object\") {\n      throw new Error(\n        `value should be an object including fields you want to update.`\n      );\n    }\n\n    const { dbSet } = await this.#thunder(\"mutation\")({\n      dbSet: [\n        {\n          userId,\n          value: serialize(value).toString(\"base64\")\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on DbSetResponse\": {\n            __typename: true,\n            dbSet: true\n          }\n        }\n      ]\n    });\n\n    if (!dbSet) {\n      return null;\n    }\n\n    if (dbSet.__typename === \"ErrorAccessDenied\") {\n      return dbSet;\n    }\n\n    if (dbSet.__typename === \"ErrorNotFound\") {\n      return dbSet;\n    }\n\n    if (!dbSet.dbSet) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: (dbSet.dbSet as { res: T }).res\n    };\n  }\n\n  async dbSearch<T>({\n    search,\n    field\n  }: {\n    field: string;\n    search: string;\n  }): Promise<\n    SuccessResponse<T[]> | ErrorAccessDenied | ErrorBasic | ErrorNotExist | null\n  > {\n    const { dbSearch } = await this.#thunder(\"query\", {\n      scalars: {\n        Json: {\n          encode: (e: unknown) => JSON.stringify(e),\n          decode: (e: unknown) => JSON.parse(e as string)\n        },\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        },\n        BigInt: {\n          decode: (e: unknown) => BigInt(e as string),\n          encode: (e: unknown) => (e as bigint).toString()\n        }\n      }\n    })({\n      dbSearch: [\n        {\n          search,\n          field\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorBasic\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorNotExist\": {\n            __typename: true,\n            message: true\n          },\n          \"...on DbSearchResponse\": {\n            __typename: true,\n            json: true\n          }\n        }\n      ]\n    });\n\n    if (!dbSearch) {\n      return null;\n    }\n\n    if (dbSearch.__typename === \"ErrorAccessDenied\") {\n      return dbSearch;\n    }\n\n    if (dbSearch.__typename === \"ErrorBasic\") {\n      return dbSearch;\n    }\n\n    if (dbSearch.__typename === \"ErrorNotExist\") {\n      return dbSearch;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: dbSearch.json as unknown as T[]\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/client/SecrecyMailClient.d.ts

@@ -0,0 +1,42 @@
+import type { ErrorAccessDenied, ErrorBasic, ErrorNotFound } from "../error.js";
+import type { SuccessResponse, KeyPair, NewMail, SecrecyClient } from "../index.js";
+import type { MailType, Thunder } from "../zeus/index.js";
+import type { DraftMail, Mail, ReceivedMail, SentMail, WaitingReceivedMail } from "./types/index.js";
+export declare class SecrecyMailClient {
+    #private;
+    constructor(client: SecrecyClient, keys: KeyPair, thunder: ReturnType<typeof Thunder>);
+    get({ id }: {
+        id: string;
+    }): Promise<SuccessResponse<Mail> | ErrorAccessDenied | null>;
+    recover({ mailId }: {
+        mailId: string;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorBasic | null>;
+    deletedMails({ mailType }: {
+        mailType: MailType;
+    }): Promise<SuccessResponse<Mail[]> | ErrorAccessDenied | null>;
+    create(data: NewMail, customMessage?: string | null | undefined): Promise<SuccessResponse<boolean> | ErrorBasic | ErrorAccessDenied | null>;
+    waitingReceivedMails(): Promise<SuccessResponse<WaitingReceivedMail[]> | ErrorNotFound | null>;
+    updateDraft(draftId: string, { body, subject, files, recipientsIds, replyTo }: Partial<NewMail>): Promise<SuccessResponse<DraftMail> | ErrorNotFound | ErrorAccessDenied | ErrorBasic | null>;
+    deleteDraft(draftId: string): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    deleteTrash({ ids }: {
+        ids: Array<string>;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    emptyTrash(): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    delete({ mailId }: {
+        mailId: string;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    sendDraft(draftId: string, customMessage?: string | null | undefined): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorBasic | null>;
+    sendWaitingEmails(): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorBasic | null>;
+    createDraft({ body, subject, files, recipientsIds, replyTo }: NewMail): Promise<SuccessResponse<DraftMail> | ErrorAccessDenied | ErrorBasic | null>;
+    read({ mailId }: {
+        mailId: string;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorBasic | ErrorNotFound | null>;
+    unread({ mailId }: {
+        mailId: string;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorBasic | ErrorNotFound | null>;
+    receivedMails(): Promise<SuccessResponse<ReceivedMail[]> | ErrorNotFound | null>;
+    sentMails(): Promise<SuccessResponse<SentMail[]> | ErrorNotFound | null>;
+    draftMails(): Promise<SuccessResponse<DraftMail[]> | ErrorNotFound | null>;
+    unreadReceivedMailsCount(): Promise<SuccessResponse<number> | ErrorAccessDenied | null>;
+    private _eachUser;
+}