create-dovite 2.2.0 → 2.2.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-dovite",
-  "version": "2.2.0",
-  "description": "Vite template featuring Tailwind (v4), ShadCN (Canary), and DOMO integration.",
+  "version": "2.2.2",
+  "description": "Vite template featuring React, Vue, TailwindCSS, ShadCN, and DOMO integration.",
   "main": "index.js",
   "bin": {
     "create-dovite": "index.js"
@@ -9,8 +9,8 @@
   "files": [
     "templates/react-js",
     "templates/react-ts",
-    "templates/index.jsx",
-    "templates/index.css",
+    "templates/vue-js",
+    "templates/vue-ts",
     "src",
     "index.js"
   ],
@@ -21,6 +21,7 @@
     "shadcn",
     "domo",
     "react",
+    "vue",
     "create-vite"
   ],
   "author": "Ajay B",

package/src/prompts.js

@@ -22,9 +22,8 @@ async function getProjectDetails(initialProjectName) {
     choices: [
       { title: "React JavaScript", value: "react-js" },
       { title: "React TypeScript", value: "react-ts" },
-      // Vue templates coming soon in a future release
-      // { title: "Vue JavaScript", value: "vue-js" },
-      // { title: "Vue TypeScript", value: "vue-ts" },
+      { title: "Vue JavaScript", value: "vue-js" },
+      { title: "Vue TypeScript", value: "vue-ts" },
     ],
     initial: 0,
   });

package/templates/vue-js/jsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}

package/templates/vue-js/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/vue-js/src/API/currentUserContext.js

@@ -0,0 +1,61 @@
+import { ref, provide, inject, onMounted } from "vue";
+import DomoApi from "./domoAPI";
+
+// Create a symbol for the injection key
+const UserContextKey = Symbol("UserContext");
+
+// Composable to provide user context
+export function useUserProvider() {
+  const currentUser = ref("");
+  const currentUserId = ref("");
+  const avatarKey = ref("");
+  const customer = ref("");
+  const host = ref("");
+
+  onMounted(() => {
+    let isUserFetched = false;
+
+    DomoApi.GetCurrentUser().then((data) => {
+      if (!isUserFetched) {
+        const userId = data?.userId;
+        const displayName = data?.displayName;
+        const avatar = data?.avatarKey;
+        const cust = data?.customer;
+        const hostVal = data?.host;
+
+        currentUser.value = displayName || "";
+        currentUserId.value = userId || "";
+        avatarKey.value = avatar || "";
+        customer.value = cust || "";
+        host.value = hostVal || "";
+
+        isUserFetched = true;
+      }
+    });
+  });
+
+  const userContext = {
+    currentUser,
+    currentUserId,
+    avatarKey,
+    customer,
+    host,
+  };
+
+  provide(UserContextKey, userContext);
+
+  return userContext;
+}
+
+// Composable to consume user context
+export function useUserContext() {
+  const context = inject(UserContextKey);
+  if (!context) {
+    throw new Error(
+      "useUserContext must be used within a component that calls useUserProvider"
+    );
+  }
+  return context;
+}
+
+export { UserContextKey };

package/templates/vue-js/src/API/dataApi.js

@@ -0,0 +1,238 @@
+import domo from "ryuu.js";
+import axios from "axios";
+
+export async function fetchAIData(prompt, template, maxWords) {
+  try {
+    // Validate the required "prompt" parameter
+    if (!prompt || typeof prompt !== "string") {
+      throw new Error(
+        "The 'prompt' parameter is required and must be a string."
+      );
+    }
+
+    // Construct the body dynamically, including properties only if they are valid
+    const body = {
+      input: prompt,
+      ...(template &&
+        typeof template === "string" && {
+          promptTemplate: {
+            template,
+          },
+        }),
+      ...(maxWords &&
+        !isNaN(maxWords) && {
+          parameters: {
+            max_words: maxWords.toString(),
+          },
+        }),
+    };
+
+    // Send the POST request
+    const response = await domo.post(`/domo/ai/v1/text/generation`, body);
+    console.log("AI Response:", response.output);
+
+    return response?.output;
+  } catch (error) {
+    console.error("Error fetching data:", error);
+    throw error; // Re-throw the error for better upstream handling
+  }
+}
+
+export async function fetchData(dataset) {
+  try {
+    const response = await domo.get(`/data/v1/${dataset}`).then((data) => {
+      return data;
+    });
+    // console.log(response);
+    return response;
+  } catch (error) {
+    console.error("Error fetching data:", error);
+  }
+}
+
+export async function fetchSqlData(dataset, query) {
+  // console.log("Query",query);
+
+  // Ensure the query is a string
+  if (typeof query !== "string") {
+    throw new Error("Query must be a string");
+  }
+
+  try {
+    // Fetch data from the API
+    const apiData = await domo
+      .post(`/sql/v1/${dataset}`, query, { contentType: "text/plain" })
+      .then((data) => {
+        // console.log('Fetched Data:', data);
+        return data;
+      });
+
+    // Validate the fetched data
+    if (!apiData || !apiData.columns || !apiData.rows) {
+      throw new Error("Invalid data received from the API");
+    }
+
+    // Extract and clean column names
+    const cleanedColumns = apiData.columns.map((column) => {
+      return column
+        .replace(/`/g, "")
+        .replace(/T1\./g, "")
+        .replace(/avg\((.*?)\)/i, "$1")
+        .trim();
+    });
+
+    // Map rows to cleaned column names
+    const jsonResult = apiData.rows.map((row) => {
+      const jsonObject = {};
+      cleanedColumns.forEach((cleanedColumn, index) => {
+        jsonObject[cleanedColumn] = row[index];
+      });
+      return jsonObject;
+    });
+
+    // console.log("Mapped SQL DATA",jsonResult);
+
+    // Return the dynamically created JSON
+    return jsonResult;
+  } catch (error) {
+    console.error("Error fetching or processing data:", error);
+    throw error; // Rethrow the error for the caller to handle
+  }
+}
+
+export async function sendEmail(to, subject, body, attachment) {
+  const data = {
+    to,
+    subject,
+    body,
+    ...(attachment && { attachment: [attachment] }),
+  };
+
+  if (data) {
+    try {
+      const response = await domo.post(
+        `/domo/workflow/v1/models/email/start`,
+        data
+      );
+      if (response) {
+        console.log("response", response);
+      }
+    } catch (err) {
+      console.error("Error sending email:", err);
+    }
+  }
+}
+
+//Dataflow
+export const DataflowsActions = async (action, dataflowId) => {
+  const data = {
+    action,
+    dataflowId,
+    result: true,
+  };
+
+  if (data) {
+    try {
+      const response = await domo.post(
+        `/domo/workflow/v1/models/dataflow/start`,
+        data
+      );
+      if (response) {
+        console.log("response", response);
+      }
+    } catch (err) {
+      console.error("Error sending email:", err);
+    }
+  }
+};
+export const generateAccessToken = async (clientId, clientSecret) => {
+  const tokenUrl = "https://api.domo.com/oauth/token";
+  try {
+    const response = await axios.post(
+      tokenUrl,
+      new URLSearchParams({
+        grant_type: "client_credentials",
+        scope: "user",
+      }).toString(),
+      {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+        },
+        auth: {
+          username: clientId,
+          password: clientSecret,
+        },
+      }
+    );
+    console.log("Response:", response);
+
+    console.log("Access Token:", response.data.access_token);
+
+    return response.data.access_token;
+  } catch (err) {
+    console.error("Error:", err);
+    throw err;
+  }
+};
+
+//List Of Users
+export const fetchUsers = async (accessToken) => {
+  const userUrl = `https://api.domo.com/v1/users?limit=500`;
+  console.log("accessToken", accessToken);
+  try {
+    if (!accessToken) {
+      console.log("Access token not found");
+      return;
+    }
+    const response = await axios.get(userUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+    console.log("List of users with access token", response.data);
+    return response.data;
+  } catch (err) {
+    console.error("Error fetching User details:", err);
+  }
+};
+
+//List Of Dataset
+export const fetchDatasets = async (accessToken) => {
+  const datasetUrl = `https://api.domo.com/v1/datasets`;
+
+  try {
+    if (!accessToken) {
+      await generateAccessToken();
+    }
+    const response = await axios.get(datasetUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+    // console.log("List of dataset", response.data);
+    return response.data;
+  } catch (err) {
+    console.error("Error fetching dataset details:", err);
+  }
+};
+
+//Perticaular Dataset Details
+export const fetchDatasetDetails = async (accessToken, datasetId) => {
+  const datasetUrl = `https://api.domo.com/v1/datasets/${datasetId}`;
+
+  try {
+    if (!accessToken) {
+      await generateAccessToken();
+    }
+
+    const response = await axios.get(datasetUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+    // console.log("data", response.data)
+    return response.data;
+  } catch (err) {
+    console.error("Error fetching dataset details:", err);
+  }
+};

package/templates/vue-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/vue-js/src/App.vue

@@ -0,0 +1,9 @@
+<script setup>
+import DefaultPage from "./pages/index.vue";
+</script>
+
+<template>
+  <DefaultPage />
+</template>
+
+<style scoped></style>

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

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

package/templates/vue-js/src/main.js

@@ -0,0 +1,6 @@
+import { createApp } from "vue";
+import "./style.css";
+import "./index.css";
+import App from "./App.vue";
+
+createApp(App).mount("#app");