create-dovite 2.2.0 → 2.2.2

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

@@ -0,0 +1,40 @@
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+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: [
+    vue(),
+    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/vue-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/vue-ts/src/API/currentUserContext.ts

@@ -0,0 +1,76 @@
+import {
+  ref,
+  provide,
+  inject,
+  onMounted,
+  type Ref,
+  type InjectionKey,
+} from "vue";
+import DomoApi from "./domoAPI";
+
+// Define the user context interface
+export interface UserContextType {
+  currentUser: Ref<string>;
+  currentUserId: Ref<string>;
+  avatarKey: Ref<string>;
+  customer: Ref<string>;
+  host: Ref<string>;
+}
+
+// Create a typed symbol for the injection key
+export const UserContextKey: InjectionKey<UserContextType> =
+  Symbol("UserContext");
+
+// Composable to provide user context
+export function useUserProvider(): UserContextType {
+  const currentUser = ref<string>("");
+  const currentUserId = ref<string>("");
+  const avatarKey = ref<string>("");
+  const customer = ref<string>("");
+  const host = ref<string>("");
+
+  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: UserContextType = {
+    currentUser,
+    currentUserId,
+    avatarKey,
+    customer,
+    host,
+  };
+
+  provide(UserContextKey, userContext);
+
+  return userContext;
+}
+
+// Composable to consume user context
+export function useUserContext(): UserContextType {
+  const context = inject(UserContextKey);
+  if (!context) {
+    throw new Error(
+      "useUserContext must be used within a component that calls useUserProvider"
+    );
+  }
+  return context;
+}

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

@@ -0,0 +1,284 @@
+import domo from "ryuu.js";
+import axios from "axios";
+
+interface AIResponseBody {
+  input: string;
+  promptTemplate?: {
+    template: string;
+  };
+  parameters?: {
+    max_words: string;
+  };
+}
+
+interface SqlApiData {
+  columns: string[];
+  rows: any[][];
+}
+
+interface EmailData {
+  to: string;
+  subject: string;
+  body: string;
+  attachment?: any[];
+}
+
+interface DataflowData {
+  action: string;
+  dataflowId: string;
+  result: boolean;
+}
+
+export async function fetchAIData(
+  prompt: string,
+  template?: string,
+  maxWords?: number
+): Promise<string | undefined> {
+  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: AIResponseBody = {
+      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<T = any>(
+  dataset: string
+): Promise<T | undefined> {
+  try {
+    const response = await domo.get(`/data/v1/${dataset}`).then((data: T) => {
+      return data;
+    });
+    return response;
+  } catch (error) {
+    console.error("Error fetching data:", error);
+  }
+}
+
+export async function fetchSqlData<T = Record<string, any>>(
+  dataset: string,
+  query: string
+): Promise<T[]> {
+  // 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: SqlApiData = await domo
+      .post(`/sql/v1/${dataset}`, query, { contentType: "text/plain" })
+      .then((data: SqlApiData) => {
+        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: string) => {
+      return column
+        .replace(/`/g, "")
+        .replace(/T1\./g, "")
+        .replace(/avg\((.*?)\)/i, "$1")
+        .trim();
+    });
+
+    // Map rows to cleaned column names
+    const jsonResult = apiData.rows.map((row: any[]) => {
+      const jsonObject: Record<string, any> = {};
+      cleanedColumns.forEach((cleanedColumn: string, index: number) => {
+        jsonObject[cleanedColumn] = row[index];
+      });
+      return jsonObject as T;
+    });
+
+    return jsonResult;
+  } catch (error) {
+    console.error("Error fetching or processing data:", error);
+    throw error;
+  }
+}
+
+export async function sendEmail(
+  to: string,
+  subject: string,
+  body: string,
+  attachment?: any
+): Promise<void> {
+  const data: EmailData = {
+    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: string,
+  dataflowId: string
+): Promise<void> => {
+  const data: DataflowData = {
+    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: string,
+  clientSecret: string
+): Promise<string> => {
+  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: string
+): Promise<any[] | undefined> => {
+  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: string
+): Promise<any[] | undefined> => {
+  const datasetUrl = `https://api.domo.com/v1/datasets`;
+
+  try {
+    if (!accessToken) {
+      await generateAccessToken("", "");
+    }
+    const response = await axios.get(datasetUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+    return response.data;
+  } catch (err) {
+    console.error("Error fetching dataset details:", err);
+  }
+};
+
+// Particular Dataset Details
+export const fetchDatasetDetails = async (
+  accessToken: string,
+  datasetId: string
+): Promise<any | undefined> => {
+  const datasetUrl = `https://api.domo.com/v1/datasets/${datasetId}`;
+
+  try {
+    if (!accessToken) {
+      await generateAccessToken("", "");
+    }
+
+    const response = await axios.get(datasetUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+    return response.data;
+  } catch (err) {
+    console.error("Error fetching dataset details:", err);
+  }
+};