Initial commit: Plane

Synced from upstream: 8853637e981ed7d8a6cff32bd98e7afe20f54362

apps/web/core/local-db/utils/utils.ts

@@ -0,0 +1,206 @@
+import { pick } from "lodash-es";
+import type { TIssue } from "@plane/types";
+import { rootStore } from "@/lib/store-context";
+import { persistence } from "../storage.sqlite";
+import { updateIssue } from "./load-issues";
+
+export const log = (...args: any) => {
+  if ((window as any).DEBUG) {
+    console.log(...args);
+  }
+};
+export const logError = (e: any) => {
+  if (e?.result?.errorClass === "SQLite3Error") {
+    e = parseSQLite3Error(e);
+  }
+  console.error(e);
+};
+export const logInfo = console.info;
+
+export const addIssueToPersistanceLayer = async (issue: TIssue) => {
+  try {
+    const issuePartial = pick({ ...JSON.parse(JSON.stringify(issue)) }, [
+      "id",
+      "name",
+      "state_id",
+      "sort_order",
+      "completed_at",
+      "estimate_point",
+      "priority",
+      "start_date",
+      "target_date",
+      "sequence_id",
+      "project_id",
+      "parent_id",
+      "created_at",
+      "updated_at",
+      "created_by",
+      "updated_by",
+      "is_draft",
+      "archived_at",
+      "state__group",
+      "cycle_id",
+      "link_count",
+      "attachment_count",
+      "sub_issues_count",
+      "assignee_ids",
+      "label_ids",
+      "module_ids",
+      "type_id",
+      "description_html",
+    ]);
+    await updateIssue({ ...issuePartial, is_local_update: 1 });
+  } catch (e) {
+    logError("Error while adding issue to db");
+  }
+};
+
+export const updatePersistentLayer = async (issueIds: string | string[]) => {
+  if (typeof issueIds === "string") {
+    issueIds = [issueIds];
+  }
+  issueIds.forEach(async (issueId) => {
+    const dbIssue = await persistence.getIssue(issueId);
+    const issue = rootStore.issue.issues.getIssueById(issueId);
+    const updatedIssue = dbIssue ? { ...dbIssue, ...issue } : issue;
+
+    if (updatedIssue) {
+      addIssueToPersistanceLayer(updatedIssue);
+    }
+  });
+};
+
+export const wrapDateTime = (field: string) => {
+  const DATE_TIME_FIELDS = ["created_at", "updated_at", "completed_at", "start_date", "target_date"];
+
+  if (DATE_TIME_FIELDS.includes(field)) {
+    return `datetime(${field})`;
+  }
+  return field;
+};
+
+export const getGroupedIssueResults = (issueResults: (TIssue & { group_id?: string; total_issues: number })[]): any => {
+  const groupedResults: {
+    [key: string]: {
+      results: TIssue[];
+      total_results: number;
+    };
+  } = {};
+
+  for (const issue of issueResults) {
+    const { group_id, total_issues } = issue;
+    const groupId = group_id ? group_id : "None";
+    if (groupedResults?.[groupId] !== undefined && Array.isArray(groupedResults?.[groupId]?.results)) {
+      groupedResults?.[groupId]?.results.push(issue);
+    } else {
+      groupedResults[groupId] = { results: [issue], total_results: total_issues };
+    }
+  }
+
+  return groupedResults;
+};
+
+export const getSubGroupedIssueResults = (
+  issueResults: (TIssue & { group_id?: string; total_issues: number; sub_group_id?: string })[]
+): any => {
+  const subGroupedResults: {
+    [key: string]: {
+      results: {
+        [key: string]: {
+          results: TIssue[];
+          total_results: number;
+        };
+      };
+      total_results: number;
+    };
+  } = {};
+
+  for (const issue of issueResults) {
+    const { group_id, total_issues, sub_group_id } = issue;
+    const groupId = group_id ? group_id : "None";
+    const subGroupId = sub_group_id ? sub_group_id : "None";
+
+    if (subGroupedResults?.[groupId] === undefined) {
+      subGroupedResults[groupId] = { results: {}, total_results: 0 };
+    }
+
+    if (
+      subGroupedResults[groupId].results[subGroupId] !== undefined &&
+      Array.isArray(subGroupedResults[groupId].results[subGroupId]?.results)
+    ) {
+      subGroupedResults[groupId].results[subGroupId]?.results.push(issue);
+    } else {
+      subGroupedResults[groupId].results[subGroupId] = { results: [issue], total_results: total_issues };
+    }
+  }
+
+  const groupByKeys = Object.keys(subGroupedResults);
+
+  for (const groupByKey of groupByKeys) {
+    let totalIssues = 0;
+    const groupedResults = subGroupedResults[groupByKey]?.results ?? {};
+    const subGroupByKeys = Object.keys(groupedResults);
+
+    for (const subGroupByKey of subGroupByKeys) {
+      const subGroupedResultsCount = groupedResults[subGroupByKey].total_results ?? 0;
+      totalIssues += subGroupedResultsCount;
+    }
+
+    subGroupedResults[groupByKey].total_results = totalIssues;
+  }
+
+  return subGroupedResults;
+};
+
+export const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const parseSQLite3Error = (error: any) => {
+  error.result = JSON.stringify(error.result);
+  return error;
+};
+
+export const isChrome = () => {
+  const userAgent = navigator.userAgent;
+  return userAgent.includes("Chrome") && !userAgent.includes("Edg") && !userAgent.includes("OPR");
+};
+
+export const clearOPFS = async (force = false) => {
+  const storageManager = window.navigator.storage;
+  const root = await storageManager.getDirectory();
+
+  if (force && isChrome()) {
+    await (root as any).remove({ recursive: true });
+    return;
+  }
+  // ts-ignore
+  for await (const entry of (root as any)?.values()) {
+    if (entry.kind === "directory" && entry.name.startsWith(".ahp-")) {
+      // A lock with the same name as the directory protects it from
+      // being deleted.
+
+      if (force) {
+        // don't wait for the lock
+        try {
+          await root.removeEntry(entry.name, { recursive: true });
+        } catch (e) {
+          console.log(e);
+        }
+      } else {
+        await navigator.locks.request(entry.name, { ifAvailable: true }, async (lock) => {
+          if (lock) {
+            log?.(`Deleting temporary directory ${entry.name}`);
+            try {
+              await root.removeEntry(entry.name, { recursive: true });
+            } catch (e) {
+              console.log(e);
+            }
+          } else {
+            log?.(`Temporary directory ${entry.name} is in use`);
+          }
+        });
+      }
+    } else {
+      root.removeEntry(entry.name);
+    }
+  }
+};