@lasterp/shared 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/rn/index.js

@@ -0,0 +1,496 @@
+// src/frappe/provider.tsx
+import { useMemo, createContext } from "react";
+import { FrappeApp } from "frappe-js-sdk";
+
+// src/frappe/socket.ts
+import io from "socket.io-client";
+
+class SocketIO {
+  socket_port;
+  host;
+  port;
+  protocol;
+  url;
+  site_name;
+  socket;
+  constructor(url, site_name, socket_port, tokenParams) {
+    this.socket_port = socket_port ?? "9000";
+    this.host = window.location?.hostname;
+    this.port = window.location?.port ? `:${this.socket_port}` : "";
+    this.protocol = window.location?.protocol === "https:" ? "https" : "http";
+    if (url) {
+      let urlObject = new URL(url);
+      urlObject.port = "";
+      if (socket_port) {
+        urlObject.port = socket_port;
+        this.url = urlObject.toString();
+      } else {
+        this.url = urlObject.toString();
+      }
+    } else {
+      this.url = `${this.protocol}://${this.host}${this.port}/`;
+    }
+    if (site_name) {
+      this.url = `${this.url}${site_name}`;
+    }
+    this.site_name = site_name;
+    this.socket = io(`${this.url}`, {
+      withCredentials: true,
+      secure: this.protocol === "https",
+      extraHeaders: tokenParams && tokenParams.useToken === true ? {
+        Authorization: `${tokenParams.type} ${tokenParams.token?.()}`
+      } : {}
+    });
+  }
+}
+
+// src/frappe/provider.tsx
+import { jsxDEV } from "react/jsx-dev-runtime";
+var FrappeContext = createContext(null);
+var FrappeProvider = ({
+  url = "",
+  tokenParams,
+  enableSocket = true,
+  socketPort,
+  siteName,
+  children,
+  customHeaders
+}) => {
+  const frappeConfig = useMemo(() => {
+    const frappe = new FrappeApp(url, tokenParams, undefined, customHeaders);
+    return {
+      url,
+      tokenParams,
+      app: frappe,
+      auth: frappe.auth(),
+      db: frappe.db(),
+      call: frappe.call(),
+      file: frappe.file(),
+      socket: enableSocket ? new SocketIO(url, siteName, socketPort, tokenParams).socket : undefined
+    };
+  }, [url, tokenParams, enableSocket, socketPort, siteName, customHeaders]);
+  return /* @__PURE__ */ jsxDEV(FrappeContext.Provider, {
+    value: frappeConfig,
+    children
+  }, undefined, false, undefined, this);
+};
+// src/frappe/hooks/auth.ts
+import { useCallback, useContext, useState, useEffect } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+var useFrappeAuth = () => {
+  const queryClient = useQueryClient();
+  const { auth, tokenParams } = useContext(FrappeContext);
+  const [userID, setUserID] = useState();
+  const getUserCookie = useCallback(() => {
+    const userCookie = document.cookie.split(";").find((c) => c.trim().startsWith("user_id="));
+    if (userCookie) {
+      const userName = userCookie.split("=")[1];
+      if (userName && userName !== "Guest") {
+        setUserID(userName);
+      } else {
+        setUserID(null);
+      }
+    } else {
+      setUserID(null);
+    }
+  }, []);
+  useEffect(() => {
+    if (tokenParams && tokenParams.useToken) {
+      setUserID(null);
+    } else {
+      getUserCookie();
+    }
+  }, [tokenParams, getUserCookie]);
+  const {
+    data: currentUser,
+    error,
+    isLoading,
+    isFetching: isValidating
+  } = useQuery({
+    queryKey: ["currentUser", { tokenParams, userID }],
+    queryFn: () => auth.getLoggedInUser(),
+    enabled: !!(tokenParams?.useToken || userID),
+    retry: false,
+    refetchOnWindowFocus: false,
+    staleTime: Infinity
+  });
+  const loginMutation = useMutation({
+    mutationFn: (credentials) => auth.loginWithUsernamePassword(credentials),
+    onSuccess: () => {
+      getUserCookie();
+      queryClient.invalidateQueries({ queryKey: ["currentUser"] });
+    }
+  });
+  const logoutMutation = useMutation({
+    mutationFn: () => auth.logout(),
+    onSuccess: () => {
+      setUserID(null);
+      queryClient.setQueryData(["currentUser"], null);
+    }
+  });
+  return {
+    isLoading: userID === undefined || isLoading,
+    currentUser,
+    isValidating,
+    error,
+    login: loginMutation.mutateAsync,
+    logout: logoutMutation.mutateAsync,
+    updateCurrentUser: () => queryClient.invalidateQueries({ queryKey: ["currentUser"] }),
+    getUserCookie
+  };
+};
+// src/frappe/hooks/call.ts
+import { useContext as useContext2 } from "react";
+import { useMutation as useMutation2, useQuery as useQuery2 } from "@tanstack/react-query";
+
+// src/frappe/utils.ts
+function encodeQueryData(data) {
+  const ret = [];
+  for (let d in data)
+    ret.push(encodeURIComponent(d) + "=" + encodeURIComponent(data[d]));
+  return ret.join("&");
+}
+
+// src/frappe/hooks/call.ts
+var useFrappeGetCall = (method, params, options, type = "GET") => {
+  const { call } = useContext2(FrappeContext);
+  const urlParams = encodeQueryData(params ?? {});
+  const url = `${method}?${urlParams}`;
+  const queryKey = ["frappeCall", type, method, url];
+  const { data, error, isLoading, isFetching, refetch } = useQuery2({
+    queryKey,
+    queryFn: type === "GET" ? () => call.get(method, params) : () => call.post(method, params),
+    enabled: (options?.enabled ?? true) && !!method,
+    staleTime: options?.staleTime,
+    retry: options?.retry ?? false
+  });
+  return {
+    data,
+    error,
+    isLoading,
+    isFetching,
+    refetch
+  };
+};
+var useFrappeMutation = (method, httpMethod) => {
+  const { call: frappeCall } = useContext2(FrappeContext);
+  const queryKey = ["frappeCall", httpMethod, method];
+  const { mutateAsync, data, isPending, error, isSuccess, reset } = useMutation2({
+    mutationKey: queryKey,
+    mutationFn: (params) => {
+      if (httpMethod === "POST")
+        return frappeCall.post(method, params);
+      if (httpMethod === "PUT")
+        return frappeCall.put(method, params);
+      return frappeCall.delete(method, params);
+    }
+  });
+  return {
+    call: (params) => mutateAsync(params),
+    result: data ?? null,
+    loading: isPending,
+    error,
+    isCompleted: isSuccess,
+    reset
+  };
+};
+var useFrappePostCall = (method) => useFrappeMutation(method, "POST");
+var useFrappePutCall = (method) => useFrappeMutation(method, "PUT");
+var useFrappeDeleteCall = (method) => useFrappeMutation(method, "DELETE");
+// src/frappe/hooks/count.ts
+import { useContext as useContext3 } from "react";
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+var useFrappeGetDocCount = (doctype, filters, debug = false, options) => {
+  const { url, db } = useContext3(FrappeContext);
+  const queryKey = ["docCount", url, doctype, filters ?? [], debug];
+  const { data, error, isLoading, isFetching, refetch } = useQuery3({
+    queryKey,
+    queryFn: () => db.getCount(doctype, filters, debug),
+    enabled: !!doctype,
+    ...options
+  });
+  return {
+    data,
+    error,
+    isLoading,
+    isFetching,
+    refetch
+  };
+};
+// src/frappe/hooks/create.ts
+import { useContext as useContext4 } from "react";
+import { useMutation as useMutation3 } from "@tanstack/react-query";
+var useFrappeCreateDoc = () => {
+  const { db } = useContext4(FrappeContext);
+  const { mutateAsync, isPending, error, isSuccess, reset } = useMutation3({
+    mutationFn: ({ doctype, doc }) => db.createDoc(doctype, doc)
+  });
+  const createDoc = (doctype, doc) => mutateAsync({ doctype, doc });
+  return {
+    createDoc,
+    loading: isPending,
+    error,
+    isCompleted: isSuccess,
+    reset
+  };
+};
+// src/frappe/hooks/delete.ts
+import { useContext as useContext5 } from "react";
+import { useMutation as useMutation4 } from "@tanstack/react-query";
+var useFrappeDeleteDoc = () => {
+  const { db } = useContext5(FrappeContext);
+  const { mutateAsync, isPending, error, isSuccess, reset } = useMutation4({
+    mutationFn: ({ doctype, docname }) => db.deleteDoc(doctype, docname)
+  });
+  const deleteDoc = (doctype, docname) => mutateAsync({ doctype, docname });
+  return {
+    deleteDoc,
+    loading: isPending,
+    error,
+    isCompleted: isSuccess,
+    reset
+  };
+};
+// src/frappe/hooks/event.ts
+import { useCallback as useCallback2, useContext as useContext6, useState as useState2, useEffect as useEffect2 } from "react";
+var useFrappeEventListener = (eventName, callback) => {
+  const { socket } = useContext6(FrappeContext);
+  useEffect2(() => {
+    if (socket === undefined) {
+      console.warn("Socket is not enabled. Please enable socket in FrappeProvider.");
+    }
+    let listener = socket?.on(eventName, callback);
+    return () => {
+      listener?.off(eventName);
+    };
+  }, [eventName, callback, socket]);
+};
+var useFrappeDocumentEventListener = (doctype, docname, onUpdateCallback, emitOpenCloseEventsOnMount = true) => {
+  const { socket } = useContext6(FrappeContext);
+  const [viewers, setViewers] = useState2([]);
+  useEffect2(() => {
+    if (socket === undefined) {
+      console.warn("Socket is not enabled. Please enable socket in FrappeProvider.");
+    }
+    socket?.emit("doc_subscribe", doctype, docname);
+    const onReconnect = () => {
+      socket?.emit("doc_subscribe", doctype, docname);
+    };
+    socket?.io.on("reconnect", onReconnect);
+    if (emitOpenCloseEventsOnMount) {
+      socket?.emit("doc_open", doctype, docname);
+    }
+    return () => {
+      socket?.emit("doc_unsubscribe", doctype, docname);
+      if (emitOpenCloseEventsOnMount) {
+        socket?.emit("doc_close", doctype, docname);
+      }
+      socket?.io.off("reconnect", onReconnect);
+    };
+  }, [doctype, docname, emitOpenCloseEventsOnMount, socket]);
+  useFrappeEventListener("doc_update", onUpdateCallback);
+  const emitDocOpen = useCallback2(() => {
+    socket?.emit("doc_open", doctype, docname);
+  }, [doctype, docname, socket]);
+  const emitDocClose = useCallback2(() => {
+    socket?.emit("doc_close", doctype, docname);
+  }, [doctype, docname, socket]);
+  const onViewerEvent = useCallback2((data) => {
+    if (data.doctype === doctype && data.docname === docname) {
+      setViewers(data.users);
+    }
+  }, [doctype, docname]);
+  useFrappeEventListener("doc_viewers", onViewerEvent);
+  return {
+    viewers,
+    emitDocOpen,
+    emitDocClose
+  };
+};
+var useFrappeDocTypeEventListener = (doctype, onListUpdateCallback) => {
+  const { socket } = useContext6(FrappeContext);
+  useEffect2(() => {
+    if (socket === undefined) {
+      console.warn("Socket is not enabled. Please enable socket in FrappeProvider.");
+    }
+    socket?.emit("doctype_subscribe", doctype);
+    const onReconnect = () => {
+      socket?.emit("doctype_subscribe", doctype);
+    };
+    socket?.io.on("reconnect", onReconnect);
+    return () => {
+      socket?.emit("doctype_unsubscribe", doctype);
+      socket?.io.off("reconnect", onReconnect);
+    };
+  }, [doctype, socket]);
+  useFrappeEventListener("list_update", onListUpdateCallback);
+};
+// src/frappe/hooks/file.ts
+import { useContext as useContext7, useState as useState3 } from "react";
+import { useMutation as useMutation5 } from "@tanstack/react-query";
+var useFrappeFileUpload = () => {
+  const { file } = useContext7(FrappeContext);
+  const [progress, setProgress] = useState3(0);
+  const {
+    mutateAsync,
+    isPending,
+    error,
+    isSuccess,
+    reset: resetMutation
+  } = useMutation5({
+    mutationFn: ({ f, args, apiPath }) => {
+      setProgress(0);
+      return file.uploadFile(f, args, (completed, total) => {
+        if (total)
+          setProgress(Math.round(completed / total * 100));
+      }, apiPath).then((r) => {
+        setProgress(100);
+        return r.data.message;
+      });
+    }
+  });
+  const upload = (f, args, apiPath) => mutateAsync({ f, args, apiPath });
+  const reset = () => {
+    setProgress(0);
+    resetMutation();
+  };
+  return {
+    upload,
+    progress,
+    loading: isPending,
+    error: error ?? null,
+    isCompleted: isSuccess,
+    reset
+  };
+};
+// src/frappe/hooks/get.ts
+import { useContext as useContext8 } from "react";
+import { useQuery as useQuery4 } from "@tanstack/react-query";
+var useFrappeGetDoc = (doctype, name, options) => {
+  const { url, db } = useContext8(FrappeContext);
+  const queryKey = ["doc", url, doctype, name];
+  const { data, error, isLoading, isFetching, refetch } = useQuery4({
+    queryKey,
+    queryFn: () => db.getDoc(doctype, name),
+    enabled: !!name,
+    staleTime: options?.staleTime ?? 5 * 60 * 1000,
+    retry: options?.retry ?? false
+  });
+  return {
+    data,
+    error,
+    isLoading,
+    isFetching,
+    refetch
+  };
+};
+// src/frappe/hooks/list.ts
+import { useContext as useContext9 } from "react";
+import {
+  useQuery as useQuery5
+} from "@tanstack/react-query";
+var useFrappeGetDocList = (doctype, args, options) => {
+  const { url, db } = useContext9(FrappeContext);
+  const queryKey = ["docList", url, doctype, args ?? null];
+  const { data, error, isLoading, isFetching, refetch } = useQuery5({
+    queryKey,
+    queryFn: () => db.getDocList(doctype, args),
+    ...options
+  });
+  return {
+    data,
+    error: error ?? null,
+    isLoading,
+    isFetching,
+    refetch
+  };
+};
+// src/frappe/hooks/prefetch.ts
+import { useCallback as useCallback3, useContext as useContext10 } from "react";
+import { useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+var useFrappePrefetchDoc = (doctype, name, options) => {
+  const queryClient = useQueryClient2();
+  const { url, db } = useContext10(FrappeContext);
+  const preloadDoc = useCallback3(() => {
+    if (!name)
+      return;
+    const queryKey = ["doc", url, doctype, name];
+    queryClient.prefetchQuery({
+      queryKey,
+      queryFn: () => db.getDoc(doctype, name),
+      staleTime: options?.staleTime ?? 5 * 60 * 1000
+    });
+  }, [doctype, name, queryClient, options?.staleTime]);
+  return preloadDoc;
+};
+// src/frappe/hooks/search.ts
+import { useEffect as useEffect3, useState as useState4 } from "react";
+var useSearch = (doctype, text, filters = [], limit = 20, debounce = 250) => {
+  const debouncedText = useDebounce(text, debounce);
+  return useFrappeGetCall("frappe.desk.search.search_link", {
+    doctype,
+    page_length: limit,
+    txt: debouncedText,
+    filters: JSON.stringify(filters ?? [])
+  });
+};
+var useDebounce = (value, delay) => {
+  const [debouncedValue, setDebouncedValue] = useState4(value);
+  useEffect3(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+};
+// src/frappe/hooks/update.ts
+import { useContext as useContext11 } from "react";
+import { useMutation as useMutation6 } from "@tanstack/react-query";
+var useFrappeUpdateDoc = () => {
+  const { db } = useContext11(FrappeContext);
+  const { mutateAsync, isPending, error, isSuccess, reset } = useMutation6({
+    mutationFn: ({ doctype, docname, doc }) => db.updateDoc(doctype, docname, doc)
+  });
+  const updateDoc = (doctype, docname, doc) => mutateAsync({ doctype, docname, doc });
+  return {
+    updateDoc,
+    loading: isPending,
+    error,
+    isCompleted: isSuccess,
+    reset
+  };
+};
+// src/utils/char.ts
+import { camelize, decamelize, camelizeKeys, decamelizeKeys } from "humps";
+function equalsIgnoreCase(str1, str2) {
+  return str1.localeCompare(str2, undefined, { sensitivity: "accent" }) === 0;
+}
+export {
+  useSearch,
+  useFrappeUpdateDoc,
+  useFrappePutCall,
+  useFrappePrefetchDoc,
+  useFrappePostCall,
+  useFrappeGetDocList,
+  useFrappeGetDocCount,
+  useFrappeGetDoc,
+  useFrappeGetCall,
+  useFrappeFileUpload,
+  useFrappeEventListener,
+  useFrappeDocumentEventListener,
+  useFrappeDocTypeEventListener,
+  useFrappeDeleteDoc,
+  useFrappeDeleteCall,
+  useFrappeCreateDoc,
+  useFrappeAuth,
+  equalsIgnoreCase,
+  decamelizeKeys,
+  decamelize,
+  camelizeKeys,
+  camelize,
+  FrappeProvider,
+  FrappeContext
+};

package/package.json

@@ -1,50 +1,49 @@
 {
   "name": "@lasterp/shared",
-  "version": "1.0.0-alpha.2",
-  "type": "module",
-  "description": "Shared types and business logic for LastERP Web and Native apps",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    }
-  },
+  "version": "1.0.0-alpha.4",
+  "description": "Shared repo for webapp and native app",
+  "license": "MIT",
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch --onSuccess \"yalc push\"",
-    "type-check": "tsc --noEmit",
-    "dev:publish": "pnpm run build && yalc publish",
-    "dev:push": "pnpm run build && yalc push"
-  },
-  "keywords": [
-    "lasterp",
-    "shared",
-    "typescript",
-    "business-logic"
-  ],
-  "author": "",
-  "license": "ISC",
-  "packageManager": "pnpm@10.28.1",
-  "peerDependencies": {
-    "@tanstack/react-query": "^5.0.0",
-    "react": "^18.0.0 || ^19.0.0"
+    "build": "bunup",
+    "dev": "bunup --watch",
+    "type-check": "tsc --noEmit"
   },
   "devDependencies": {
+    "@types/bun": "^1.3.9",
     "@types/humps": "^2.0.6",
-    "@types/react": "^19",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3",
-    "yalc": "1.0.0-pre.53"
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "bunup": "^0.16.26",
+    "typescript": "^5.9.3"
   },
+  "peerDependencies": {
+    "typescript": ">=4.5.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "node": "./dist/node/index.js",
+      "rn": "./dist/rn/index.js",
+      "default": "./dist/node/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "dependencies": {
-    "humps": "^2.0.1"
+    "@tanstack/react-query": "^5.90.21",
+    "frappe-js-sdk": "^1.12.0",
+    "humps": "^2.0.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "socket.io-client": "^4.8.3"
   }
 }