create-dovite 2.0.0 → 2.0.1

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

@@ -0,0 +1,338 @@
+import domo from "ryuu.js";
+import axios from "axios";
+
+// --- Type Definitions ---
+
+// Quick module declaration for ryuu.js if missing types
+declare module "ryuu.js" {
+  export function get(path: string): Promise<unknown>;
+  export function post(
+    path: string,
+    body: unknown,
+    options?: unknown
+  ): Promise<unknown>;
+}
+
+interface DomoSqlResponse {
+  columns: string[];
+  rows: unknown[][];
+  metadata?: unknown;
+}
+
+interface AIResponse {
+  output?: string;
+  choices?: Array<{ output: string }>;
+}
+
+interface EmailAttachment {
+  filename: string;
+  contentType: string;
+  base64: string;
+}
+
+interface DomoUser {
+  id: number;
+  email: string;
+  role: string;
+  [key: string]: unknown;
+}
+
+interface DomoDataset {
+  id: string;
+  name: string;
+  rows: number;
+  columns: number;
+  [key: string]: unknown;
+}
+
+// --- API Functions ---
+
+/**
+ * Fetches generated text from the Domo AI service.
+ */
+export async function fetchAIData(
+  prompt: string,
+  template?: string,
+  maxWords?: number | string
+): Promise<string | null> {
+  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
+    const body: Record<string, unknown> = {
+      input: prompt,
+    };
+
+    if (template && typeof template === "string") {
+      body.promptTemplate = { template };
+    }
+
+    if (maxWords && !isNaN(Number(maxWords))) {
+      body.parameters = { max_words: maxWords.toString() };
+    }
+
+    // Send the POST request
+    const response = (await domo.post(
+      `/domo/ai/v1/text/generation`,
+      body
+    )) as AIResponse;
+
+    // console.log("AI Response:", response);
+
+    if (response?.output) {
+      return response.output;
+    }
+    if (response?.choices?.[0]?.output) {
+      return response.choices[0].output;
+    }
+
+    return null;
+  } catch (error) {
+    console.error("Error fetching AI data:", error);
+    throw error;
+  }
+}
+
+/**
+ * Simple fetch for a dataset.
+ */
+export async function fetchData(dataset: string): Promise<unknown> {
+  try {
+    const response = await domo.get(`/data/v1/${dataset}`);
+    return response;
+  } catch (error) {
+    console.error(`Error fetching dataset ${dataset}:`, error);
+    throw error;
+  }
+}
+
+/**
+ * Executes a SQL query against a Domo dataset and returns a mapped JSON array.
+ * @template T - The expected shape of the row data.
+ */
+export async function fetchSqlData<T = Record<string, unknown>>(
+  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 = (await domo.post(`/sql/v1/${dataset}`, query, {
+      contentType: "text/plain",
+    })) as DomoSqlResponse;
+
+    // Validate the fetched data
+    if (
+      !apiData ||
+      !Array.isArray(apiData.columns) ||
+      !Array.isArray(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: unknown[]) => {
+      const jsonObject: Record<string, unknown> = {};
+      cleanedColumns.forEach((cleanedColumn: string, index: number) => {
+        jsonObject[cleanedColumn] = row[index];
+      });
+      return jsonObject as T;
+    });
+
+    // console.log("Mapped SQL DATA", jsonResult);
+    return jsonResult;
+  } catch (error) {
+    console.error("Error fetching or processing SQL data:", error);
+    throw error;
+  }
+}
+
+/**
+ * Triggers a Domo Workflow email.
+ */
+export async function sendEmail(
+  to: string | string[],
+  subject: string,
+  body: string,
+  attachment?: EmailAttachment
+): Promise<void> {
+  const data: Record<string, unknown> = {
+    to,
+    subject,
+    body,
+  };
+
+  if (attachment) {
+    data.attachment = [attachment];
+  }
+
+  try {
+    const response = await domo.post(
+      `/domo/workflow/v1/models/email/start`,
+      data
+    );
+    if (response) {
+      console.log("Email sent successfully:", response);
+    }
+  } catch (err) {
+    console.error("Error sending email:", err);
+    throw err;
+  }
+}
+
+/**
+ * Triggers a Dataflow action.
+ */
+export const DataflowsActions = async (
+  action: string,
+  dataflowId: string | number
+): Promise<void> => {
+  const data = {
+    action,
+    dataflowId,
+    result: true,
+  };
+
+  try {
+    const response = await domo.post(
+      `/domo/workflow/v1/models/dataflow/start`,
+      data
+    );
+    if (response) {
+      console.log("Dataflow action response:", response);
+    }
+  } catch (err) {
+    console.error("Error triggering dataflow:", err);
+    throw err;
+  }
+};
+
+/**
+ * Generates an OAuth Access Token.
+ */
+export const generateAccessToken = async (
+  clientId: string,
+  clientSecret: string
+): Promise<string> => {
+  if (!clientId || !clientSecret) {
+    throw new Error("Client ID and Secret are required to generate a token.");
+  }
+
+  const tokenUrl = "https://api.domo.com/oauth/token";
+
+  try {
+    const response = await axios.post<{ access_token: string }>(
+      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("Access Token generated successfully");
+    return response.data.access_token;
+  } catch (err) {
+    console.error("Error generating access token:", err);
+    throw err;
+  }
+};
+
+// --- Admin/Management Functions ---
+
+export const fetchUsers = async (
+  accessToken: string
+): Promise<DomoUser[] | undefined> => {
+  if (!accessToken) {
+    console.error("Access token missing in fetchUsers");
+    return;
+  }
+
+  const userUrl = `https://api.domo.com/v1/users?limit=500`;
+
+  try {
+    const response = await axios.get<DomoUser[]>(userUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+    console.log(`Fetched ${response.data.length} users`);
+    return response.data;
+  } catch (err) {
+    console.error("Error fetching User details:", err);
+    throw err;
+  }
+};
+
+export const fetchDatasets = async (
+  accessToken: string
+): Promise<DomoDataset[] | undefined> => {
+  if (!accessToken) {
+    console.error("Access token missing in fetchDatasets");
+    return;
+  }
+
+  const datasetUrl = `https://api.domo.com/v1/datasets`;
+
+  try {
+    const response = await axios.get<DomoDataset[]>(datasetUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+    return response.data;
+  } catch (err) {
+    console.error("Error fetching dataset details:", err);
+    throw err;
+  }
+};
+
+export const fetchDatasetDetails = async (
+  accessToken: string,
+  datasetId: string
+): Promise<DomoDataset | undefined> => {
+  if (!accessToken) {
+    console.error("Access token missing in fetchDatasetDetails");
+    return;
+  }
+
+  const datasetUrl = `https://api.domo.com/v1/datasets/${datasetId}`;
+
+  try {
+    const response = await axios.get<DomoDataset>(datasetUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+    return response.data;
+  } catch (err) {
+    console.error("Error fetching dataset details:", err);
+    throw err;
+  }
+};

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

@@ -0,0 +1,355 @@
+// @ts-ignore
+import domo from "ryuu.js";
+
+const BASE_URL = "/domo/datastores/v1";
+
+export interface User {
+  userId: string;
+  userName: string;
+  displayName: string;
+  avatarKey?: string;
+  [key: string]: any;
+}
+
+export interface Document {
+  [key: string]: any;
+}
+
+export interface Aggregations {
+  groupby?: string[];
+  count?: string;
+  avg?: Record<string, string>;
+  min?: Record<string, string>;
+  max?: Record<string, string>;
+  sum?: Record<string, string>;
+  unwind?: string[];
+}
+
+export interface QueryOptions {
+  orderby?: string;
+  limit?: number;
+  offset?: number;
+}
+
+const GetCurrentUser = (): Promise<User> => {
+  return domo
+    .get("/domo/environment/v1")
+    .then((user: any) => ({
+      ...user,
+      displayName: user.userName,
+      avatarKey: `/domo/avatars/v2/USER/${user.userId}`,
+    }))
+    .catch((error: any) => {
+      console.error("Error getting current user:", error);
+      throw error;
+    });
+};
+
+const GetAllUser = (): Promise<any> => {
+  return domo
+    .get(`/domo/users/v1?limit={500}`)
+    .then((response: any) => response)
+    .catch((error: any) => {
+      console.error("Error getting All users:", error);
+      throw error;
+    });
+};
+
+const GetUser = (userId: string): Promise<User> => {
+  return domo
+    .get(`/domo/users/v1/${userId}?includeDetails=true`)
+    .then((user: any) => ({ ...user, userName: user.displayName }))
+    .catch((error: any) => {
+      console.error("Error getting user:", error);
+      throw error;
+    });
+};
+
+const CreateDocument = (
+  collectionName: string,
+  document: Document
+): Promise<any> => {
+  console.log(document);
+  console.log(collectionName);
+
+  return domo
+    .post(`${BASE_URL}/collections/${collectionName}/documents/`, {
+      content: document,
+    })
+    .then((response: any) => response)
+    .catch((error: any) => {
+      console.error("Error creating document:", error);
+      throw error;
+    });
+};
+
+const ListDocuments = (collectionName: string): Promise<any> => {
+  return domo
+    .get(`${BASE_URL}/collections/${collectionName}/documents/`)
+    .then((response: any) => response)
+    .catch((error: any) => {
+      console.error("Error listing documents:", error);
+      throw error;
+    });
+};
+
+const GetDocument = (
+  collectionName: string,
+  documentId: string
+): Promise<any> => {
+  return domo
+    .get(`${BASE_URL}/collections/${collectionName}/documents/${documentId}`)
+    .then((response: any) => response)
+    .catch((error: any) => {
+      console.error("Error getting document:", error);
+      throw error;
+    });
+};
+
+const UpdateDocument = (
+  collectionName: string,
+  documentId: string,
+  document: Document
+): Promise<any> => {
+  return domo
+    .put(`${BASE_URL}/collections/${collectionName}/documents/${documentId}`, {
+      content: document,
+    })
+    .then((response: any) => response)
+    .catch((error: any) => {
+      console.error("Error updating document:", error);
+      throw error;
+    });
+};
+
+const queryDocumentsWithAggregations = (
+  collectionName: string,
+  query: any = {},
+  aggregations: Aggregations = {},
+  options: QueryOptions = {}
+): Promise<any> => {
+  // Base URL for the query
+  let url = `${BASE_URL}/collections/${collectionName}/documents/query?`;
+
+  // Helper function to format aggregation parameters
+  const formatAggregationParams = (params: Record<string, string>) => {
+    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: any) => {
+      console.log("Query successful:", response);
+      return response;
+    })
+    .catch((error: any) => {
+      console.error("Error querying documents with aggregations:", error);
+      throw error;
+    });
+};
+
+const DeleteDocument = (
+  collectionName: string,
+  documentId: string
+): Promise<any> => {
+  return domo
+    .delete(`${BASE_URL}/collections/${collectionName}/documents/${documentId}`)
+    .then((response: any) => response.data)
+    .catch((error: any) => {
+      console.error("Error deleting document:", error);
+      throw error;
+    });
+};
+
+const QueryDocument = (
+  collectionName: string,
+  query: any = {},
+  options: QueryOptions = {}
+): Promise<any> => {
+  // 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: any) => {
+      // console.log("Query successful:", response);
+      return response;
+    })
+    .catch((error: any) => {
+      console.error("Error querying documents:", error);
+      throw error;
+    });
+};
+
+// Query documents based on a specific date range
+const queryDocumentsByDate = (
+  collectionName: string,
+  dateString: string,
+  options: QueryOptions = {}
+): Promise<any> => {
+  const query = {
+    createdOn: {
+      $lte: { $date: dateString },
+    },
+  };
+  return QueryDocument(collectionName, query, options);
+};
+
+const BulkDeleteDocuments = (
+  collectionName: string,
+  ids: string[]
+): Promise<any> => {
+  return domo
+    .delete(
+      `${BASE_URL}/collections/${collectionName}/documents/bulk?ids=${ids}`
+    )
+    .then((response: any) => response)
+    .catch((error: any) => {
+      console.error("Error bulk deleting documents:", error);
+      throw error;
+    });
+};
+
+const UploadFile = (
+  file: File,
+  name: string,
+  description: string = "",
+  isPublic: boolean = false
+): Promise<any> => {
+  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: any) => response)
+    .catch((err: any) => {
+      console.log(err);
+      throw err;
+    });
+};
+
+const UploadRevision = (file: File, fileId: string): Promise<any> => {
+  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: any) => response)
+    .catch((err: any) => {
+      console.log(err);
+      throw err;
+    });
+};
+
+const GetFile = (fileId: string, revisionId?: string): Promise<any> => {
+  const options: any = { responseType: "blob" };
+  const url = `/domo/data-files/v1/${fileId}${
+    revisionId ? `/revisions/${revisionId}` : ""
+  }`;
+  return domo
+    .get(url, options)
+    .then((data: any) => data)
+    .catch((err: any) => {
+      console.log(err);
+      throw err;
+    });
+};
+
+const ListAllUsers = async (
+  includeDetails: boolean = false,
+  limit: number = 100,
+  offset: number = 0
+): Promise<any> => {
+  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: string,
+  query: any,
+  operation: any
+): Promise<any> => {
+  const requestBody = {
+    query: query,
+    operation: operation,
+  };
+
+  console.log("Request body:", requestBody);
+
+  return domo
+    .put(
+      `${BASE_URL}/collections/${collectionName}/documents/update`,
+      requestBody
+    )
+    .then((response: any) => {
+      console.log("Document updated successfully:", response);
+      return response;
+    })
+    .catch((error: any) => {
+      console.error("Error updating document:", error);
+      throw error;
+    });
+};
+
+const DomoApi = {
+  GetCurrentUser,
+  GetAllUser,
+  GetUser,
+  CreateDocument,
+  ListDocuments,
+  DeleteDocument,
+  BulkDeleteDocuments,
+  GetDocument,
+  UpdateDocument,
+  QueryDocument,
+  queryDocumentsByDate,
+  UploadFile,
+  UploadRevision,
+  GetFile,
+  queryDocumentsWithAggregations,
+  ListAllUsers,
+  partialupdateDocument,
+};
+
+export default DomoApi;

package/templates/react-ts/src/App.tsx

@@ -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-ts/src/index.css

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