create-dovite 2.0.0 → 2.0.1

package/templates/react-js/src/API/domoAPI.js

@@ -0,0 +1,311 @@
+import domo from "ryuu.js";
+// import Download from "downloadjs";
+
+const BASE_URL = "/domo/datastores/v1";
+
+const GetCurrentUser = () => {
+  return domo
+    .get("/domo/environment/v1")
+    .then((user) => ({
+      ...user,
+      displayName: user.userName,
+      avatarKey: `/domo/avatars/v2/USER/${user.userId}`,
+    }))
+    .catch((error) => {
+      console.error("Error getting current user:", error);
+      throw error;
+    });
+};
+
+const GetAllUser = () => {
+  return domo
+    .get(`/domo/users/v1?limit={500}`)
+    .then((response) => response)
+    .catch((error) => {
+      console.error("Error getting All users:", error);
+      throw error;
+    });
+};
+
+const GetUser = (userId) => {
+  return domo
+    .get(`/domo/users/v1/${userId}?includeDetails=true`)
+    .then((user) => ({ ...user, userName: user.displayName }))
+    .catch((error) => {
+      console.error("Error getting user:", error);
+      throw error;
+    });
+};
+
+const CreateDocument = (collectionName, document) => {
+  console.log(document);
+  console.log(collectionName);
+
+  return domo
+    .post(`${BASE_URL}/collections/${collectionName}/documents/`, {
+      content: document,
+    })
+    .then((response) => response)
+    .catch((error) => {
+      console.error("Error creating document:", error);
+      throw error;
+    });
+};
+
+const ListDocuments = (collectionName) => {
+  return domo
+    .get(`${BASE_URL}/collections/${collectionName}/documents/`)
+    .then((response) => response)
+    .catch((error) => {
+      console.error("Error listing documents:", error);
+      throw error;
+    });
+};
+
+const GetDocument = (collectionName, documentId) => {
+  return domo
+    .get(`${BASE_URL}/collections/${collectionName}/documents/${documentId}`)
+    .then((response) => response)
+    .catch((error) => {
+      console.error("Error getting document:", error);
+      throw error;
+    });
+};
+
+const UpdateDocument = (collectionName, documentId, document) => {
+  return domo
+    .put(`${BASE_URL}/collections/${collectionName}/documents/${documentId}`, {
+      content: document,
+    })
+    .then((response) => response)
+    .catch((error) => {
+      console.error("Error updating document:", error);
+      throw error;
+    });
+};
+const queryDocumentsWithAggregations = (
+  collectionName,
+  query = {},
+  aggregations = {},
+  options = {}
+) => {
+  // Base URL for the query
+  let url = `${BASE_URL}/collections/${collectionName}/documents/query?`;
+
+  // Helper function to format aggregation parameters
+  const formatAggregationParams = (params) => {
+    return Object.entries(params)
+      .map(([property, alias]) => `${property} ${alias}`)
+      .join(", ");
+  };
+
+  // Append aggregation parameters to URL
+  if (aggregations.groupby) url += `groupby=${aggregations.groupby.join(",")}&`;
+  if (aggregations.count) url += `count=${aggregations.count}&`;
+  if (aggregations.avg)
+    url += `avg=${formatAggregationParams(aggregations.avg)}&`;
+  if (aggregations.min)
+    url += `min=${formatAggregationParams(aggregations.min)}&`;
+  if (aggregations.max)
+    url += `max=${formatAggregationParams(aggregations.max)}&`;
+  if (aggregations.sum)
+    url += `sum=${formatAggregationParams(aggregations.sum)}&`;
+  if (aggregations.unwind) url += `unwind=${aggregations.unwind.join(",")}&`;
+
+  // Append options to the URL
+  if (options.orderby) url += `orderby=${options.orderby}&`;
+  if (options.limit !== undefined) url += `limit=${options.limit}&`;
+  if (options.offset !== undefined) url += `offset=${options.offset}&`;
+
+  // Remove trailing "&" or "?" from the URL
+  url = url.replace(/[&?]$/, "");
+
+  return domo
+    .post(url, query)
+    .then((response) => {
+      console.log("Query successful:", response);
+      return response;
+    })
+    .catch((error) => {
+      console.error("Error querying documents with aggregations:", error);
+      throw error;
+    });
+};
+
+const DeleteDocument = (collectionName, documentId) => {
+  return domo
+    .delete(`${BASE_URL}/collections/${collectionName}/documents/${documentId}`)
+    .then((response) => response.data)
+    .catch((error) => {
+      console.error("Error deleting document:", error);
+      throw error;
+    });
+};
+
+const QueryDocument = (collectionName, query = {}, options = {}) => {
+  // Base URL for querying documents
+  let url = `${BASE_URL}/collections/${collectionName}/documents/query?`;
+
+  // Append optional parameters to the URL
+  if (options.limit !== undefined) url += `limit=${options.limit}&`;
+  if (options.offset !== undefined) url += `offset=${options.offset}&`;
+  if (options.orderby) url += `orderby=${options.orderby}&`;
+
+  // Remove trailing "&" or "?" from the URL
+  url = url.replace(/[&?]$/, "");
+
+  return domo
+    .post(url, query)
+    .then((response) => {
+      // console.log("Query successful:", response);
+      return response;
+    })
+    .catch((error) => {
+      console.error("Error querying documents:", error);
+      throw error;
+    });
+};
+
+// Query documents based on a specific date range
+const queryDocumentsByDate = (collectionName, dateString, options = {}) => {
+  const query = {
+    "createdOn": {
+      "$lte": { "$date": dateString }
+    }
+  };
+  return QueryDocument(collectionName, query, options);
+};
+
+const BulkDeleteDocuments = (collectionName, ids) => {
+  return domo
+    .delete(
+      `${BASE_URL}/collections/${collectionName}/documents/bulk?ids=${ids}`
+    )
+    .then((response) => response)
+    .catch((error) => {
+      console.error("Error bulk deleting documents:", error);
+      throw error;
+    });
+};
+
+const UploadFile = (file, name, description = "", isPublic = false) => {
+  const formData = new FormData();
+  formData.append("file", file);
+  const url = `/domo/data-files/v1?name=
+             ${name}&description=${description}&public=${isPublic}`;
+  const options = { contentType: "multipart" };
+  return domo
+    .post(url, formData, options)
+    .then((response) => response)
+    .catch((err) => {
+      console.log(err);
+      throw err;
+    });
+};
+
+const UploadRevision = (file, fileId) => {
+  const formData = new FormData();
+  formData.append("file", file);
+  const url = `/domo/data-files/v1/${fileId}`;
+  const options = { contentType: "multipart" };
+  return domo
+    .put(url, formData, options)
+    .then((response) => response)
+    .catch((err) => {
+      console.log(err);
+      throw err;
+    });
+};
+
+// const DownloadFile = (fileId, filename, revisionId) => {
+//   const options = { responseType: "blob" };
+//   const url = `/domo/data-files/v1/${fileId}${
+//     revisionId ? `/revisions/${revisionId}` : ""
+//   }`;
+//   return domo
+//     .get(url, options)
+//     .then((data) => {
+//       Download(data, filename);
+//     })
+//     .then((response) => response)
+//     .catch((err) => {
+//       console.log(err);
+//       throw err;
+//     });
+// };
+
+const GetFile = (fileId, revisionId) => {
+  const options = { responseType: "blob" };
+  const url = `/domo/data-files/v1/${fileId}${
+    revisionId ? `/revisions/${revisionId}` : ""
+  }`;
+  return domo
+    .get(url, options)
+    .then((data) => data)
+    .catch((err) => {
+      console.log(err);
+      throw err;
+    });
+};
+
+const ListAllUsers = async (
+  includeDetails = false,
+  limit = 100,
+  offset = 0
+) => {
+  try {
+    const response = await domo.get(
+      `/domo/users/v1?includeDetails=${includeDetails}&limit=${limit}&offset=${offset}`
+    );
+    return response;
+  } catch (error) {
+    console.error("Error listing users:", error);
+    throw error;
+  }
+};
+
+const partialupdateDocument = (collectionName, query, operation) => {
+  const requestBody = {
+    query: query,
+    operation: operation,
+  };
+
+  console.log("Request body:", requestBody);
+
+  return domo
+    .put(
+      `${BASE_URL}/collections/${collectionName}/documents/update`,
+      requestBody
+    )
+    .then((response) => {
+      console.log("Document updated successfully:", response);
+      return response;
+    })
+    .catch((error) => {
+      console.error("Error updating document:", error);
+      throw error;
+    });
+};
+
+const DomoApi = {
+  GetCurrentUser,
+  GetAllUser,
+  GetUser,
+  CreateDocument,
+  ListDocuments,
+  DeleteDocument,
+  BulkDeleteDocuments,
+  GetDocument,
+  UpdateDocument,
+  QueryDocument,
+  queryDocumentsByDate,
+  UploadFile,
+  UploadRevision,
+  // DownloadFile,
+  GetFile,
+  queryDocumentsWithAggregations,
+  ListAllUsers,
+  partialupdateDocument,
+};
+
+export default DomoApi;

package/templates/react-js/src/App.jsx

@@ -0,0 +1,13 @@
+import { useState } from "react";
+import { Button } from "./components/ui/button";
+import "./App.css";
+function App() {
+  const [count, setCount] = useState(0);
+  return (
+    <div className="App">
+      <Button onClick={() => setCount(count + 1)}>Count: {count}</Button>
+    </div>
+  );
+}
+
+export default App;

package/templates/react-js/src/index.css

@@ -0,0 +1 @@
+@import "tailwindcss";

package/templates/react-js/vite.config.js

@@ -0,0 +1,40 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import path from "path";
+import { Proxy } from "@domoinc/ryuu-proxy";
+import manifest from "./public/manifest.json";
+import tailwindcss from "@tailwindcss/vite";
+
+const config = { manifest };
+const proxy = new Proxy(config);
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [
+    react(),
+    tailwindcss(),
+    {
+      name: "ryuu-proxy",
+      configureServer(server) {
+        server.middlewares.use((req, res, next) => {
+          res.status = function (code) {
+            this.statusCode = code;
+            return this;
+          };
+          res.send = function (body) {
+            this.setHeader("Content-Type", "text/plain");
+            this.end(body);
+          };
+          next();
+        });
+        server.middlewares.use(proxy.express());
+      },
+    },
+  ],
+  define: { "process.env": {} },
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+});

package/templates/react-ts/public/manifest.json

@@ -0,0 +1,12 @@
+{
+  "name": "project-name",
+  "version": "0.0.1",
+  "size": {
+    "width": 3,
+    "height": 3
+  },
+  "mapping": [],
+  "collections": [],
+  "workflowMapping": [],
+  "packagesMapping": []
+}

package/templates/react-ts/src/API/currentUserContext.tsx

@@ -0,0 +1,66 @@
+/* eslint-disable react/prop-types */
+// @ts-ignore
+import { createContext, useState, useEffect, ReactNode } from "react";
+import DomoApi from "./domoAPI";
+
+export interface UserContextType {
+  currentUser: string;
+  currentUserId: string;
+  avatarKey: string;
+  customer: string;
+  host: string;
+}
+
+export const UserContext = createContext<UserContextType | undefined>(
+  undefined
+);
+
+export const UserProvider = ({ children }: { children: ReactNode }) => {
+  const [currentUser, setCurrentUser] = useState<string>("");
+  const [currentUserId, setCurrentUserId] = useState<string>("");
+  const [avatarKey, setAvatarKey] = useState<string>("");
+  const [customer, setCustomer] = useState<string>("");
+  const [host, setHost] = useState<string>("");
+
+  useEffect(() => {
+    let isUserFetched = false;
+
+    DomoApi.GetCurrentUser().then((data: any) => {
+      // console.log("User Data",data);
+
+      if (!isUserFetched) {
+        const userId = data?.userId;
+        const displayName = data?.displayName;
+        const avatarKey = data?.avatarKey;
+        const customer = data?.customer;
+        const host = data?.host;
+
+        setCurrentUser(displayName || "");
+        setCurrentUserId(userId || "");
+        setAvatarKey(avatarKey || "");
+        setCustomer(customer || "");
+        setHost(host || "");
+
+        isUserFetched = true;
+      }
+    });
+
+    return () => {
+      isUserFetched = true;
+    };
+  }, []);
+
+  return (
+    <UserContext.Provider
+      value={{
+        currentUser,
+        currentUserId,
+        avatarKey,
+        customer,
+        host,
+      }}
+    >
+      {children}
+    </UserContext.Provider>
+  );
+};