create-dovite 2.0.0 → 2.0.1

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "create-dovite",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Vite template featuring Tailwind (v4), ShadCN (Canary), and DOMO integration.",
   "main": "index.js",
   "bin": {
     "create-dovite": "index.js"
   },
   "files": [
-    "template",
+    "templates",
+    "src",
     "index.js"
   ],
   "keywords": [

package/src/files.js

@@ -0,0 +1,72 @@
+const fs = require("fs");
+const path = require("path");
+
+function copyTemplateFiles(projectName, templateType) {
+  // __dirname is .../src
+  // templates are in .../templates
+  const templateDir = path.join(__dirname, "..", "templates", templateType);
+  const destDir = projectName; // Relative to CWD
+
+  if (fs.existsSync(templateDir)) {
+    console.log(`Copying ${templateType} template files...`);
+    const copyRecursive = (src, dest) => {
+      if (fs.statSync(src).isDirectory()) {
+        if (!fs.existsSync(dest)) {
+          fs.mkdirSync(dest, { recursive: true });
+        }
+        const files = fs.readdirSync(src);
+        for (const file of files) {
+          copyRecursive(path.join(src, file), path.join(dest, file));
+        }
+      } else {
+        fs.copyFileSync(src, dest);
+      }
+    };
+    copyRecursive(templateDir, destDir);
+  } else {
+    console.warn(`Template directory not found: ${templateDir}`);
+  }
+}
+
+function updateManifest(projectName) {
+  const publicDir = path.join(projectName, "public");
+  const manifestJsPath = path.join(publicDir, "manifest.js");
+  const manifestJsonPath = path.join(publicDir, "manifest.json");
+
+  if (fs.existsSync(manifestJsPath)) {
+    // Legacy/JS template handling
+    console.log("Updating manifest.js with project name...");
+    let manifestContent = fs.readFileSync(manifestJsPath, "utf8");
+    manifestContent = manifestContent.replace(
+      /name:\s*["']([^"']*)["']/g,
+      `name: "${projectName}"`
+    );
+    fs.writeFileSync(manifestJsPath, manifestContent);
+  } else if (fs.existsSync(manifestJsonPath)) {
+    // TS/JSON template handling
+    console.log("Updating manifest.json with project name...");
+    const manifestContent = JSON.parse(
+      fs.readFileSync(manifestJsonPath, "utf8")
+    );
+    manifestContent.name = projectName;
+    fs.writeFileSync(
+      manifestJsonPath,
+      JSON.stringify(manifestContent, null, 2)
+    );
+  } else {
+    // Create if missing (fallback)
+    if (!fs.existsSync(publicDir)) {
+      fs.mkdirSync(publicDir, { recursive: true });
+    }
+    // Default to JSON for new setup
+    console.log("Creating manifest.json with project name...");
+    const basicManifest = {
+      name: projectName,
+      version: "1.0.0",
+      description: `${projectName} application`,
+    };
+    fs.writeFileSync(manifestJsonPath, JSON.stringify(basicManifest, null, 2));
+  }
+}
+
+module.exports = { copyTemplateFiles, updateManifest };

package/src/prompts.js

@@ -0,0 +1,49 @@
+const prompts = require("prompts");
+
+async function getProjectDetails(initialProjectName) {
+  let projectName = initialProjectName;
+  let templateType = "react-js"; // default
+
+  const questions = [];
+
+  if (!projectName) {
+    questions.push({
+      type: "text",
+      name: "projectName",
+      message: "Project name:",
+      initial: "my-dovite-app",
+    });
+  }
+
+  questions.push({
+    type: "select",
+    name: "template",
+    message: "Select a template:",
+    choices: [
+      { title: "React JavaScript", value: "react-js" },
+      { title: "React TypeScript", value: "react-ts" },
+    ],
+    initial: 0,
+  });
+
+  if (questions.length > 0) {
+    const response = await prompts(questions, {
+      onCancel: () => {
+        console.log("Operation cancelled");
+        process.exit(0);
+      },
+    });
+
+    if (!projectName) projectName = response.projectName || projectName;
+    templateType = response.template;
+  }
+
+  if (!projectName) {
+    console.error("Please specify a project name");
+    process.exit(1);
+  }
+
+  return { projectName, templateType };
+}
+
+module.exports = { getProjectDetails };

package/src/setup.js

@@ -0,0 +1,106 @@
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+function createViteProject(projectName, templateType) {
+  console.log(
+    `Creating new project: ${projectName} with template ${templateType}`
+  );
+
+  const viteTemplate = templateType === "react-ts" ? "react-ts" : "react";
+  execSync(
+    `yarn create vite ${projectName} --template ${viteTemplate} --no-interactive`,
+    {
+      stdio: "inherit",
+    }
+  );
+}
+
+function updatePackageJson(projectName, templateType) {
+  console.log("Updating package name and scripts...");
+  const packageJsonPath = path.join(projectName, "package.json");
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+  packageJson.name = projectName;
+
+  packageJson.scripts = {
+    ...packageJson.scripts,
+    dev: "vite",
+    build: templateType === "react-ts" ? "tsc -b && vite build" : "vite build",
+    lint: "eslint .",
+    preview: "vite preview",
+    upload: "yarn run build && cd dist && domo publish && cd ..",
+  };
+
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+}
+
+function installDependencies(projectName) {
+  console.log("Installing dependencies...");
+  // We need to run this inside the project directory
+  // But since we are passing projectName, we can use cwd option or chdir before calling this.
+  // However, the original script chdir'd into the project.
+  // Let's assume the caller will handle chdir or we pass cwd.
+  // To keep it simple and consistent with original flow, let's assume we are IN the project dir
+  // OR we pass the cwd to execSync.
+  // The original script did `process.chdir(projectName)`.
+
+  // Let's stick to the original flow where we chdir in the main script,
+  // OR we can make these functions robust.
+  // For now, let's assume we are inside the directory for these commands to work easily
+  // without passing cwd everywhere, BUT `updatePackageJson` used `path.join`.
+  // Let's make `updatePackageJson` work with relative path, and these commands too.
+
+  // Actually, `yarn` needs to run in the project dir.
+
+  const options = { stdio: "inherit", cwd: projectName };
+
+  execSync("yarn", options);
+
+  console.log("Installing additional dependencies...");
+  execSync(
+    "yarn add tailwindcss @tailwindcss/vite @domoinc/ryuu-proxy ryuu.js tailwind-merge react-icons",
+    options
+  );
+  execSync("yarn add -D @types/node", options);
+}
+
+function initializeShadcn(projectName) {
+  console.log("Initializing shadcn...");
+  const options = { stdio: "inherit", cwd: projectName };
+  try {
+    execSync("npx shadcn@latest init", options);
+
+    // Install new dependencies after shadcn (it might add some)
+    // The original script ran yarn again.
+    console.log("Installing final dependencies...");
+    execSync("yarn", options);
+
+    execSync("npx shadcn@latest add button", options);
+  } catch (error) {
+    console.log(
+      'Note: You may need to run "npx shadcn@latest init" manually if initialization failed.'
+    );
+  }
+}
+
+function initializeGit(projectName) {
+  console.log("Initializing git");
+  const options = { stdio: "inherit", cwd: projectName };
+  try {
+    execSync("git init", options);
+    execSync("git add .", options);
+    execSync(`git commit -m "first commit"`, options);
+    execSync("git checkout -b main", options);
+  } catch (e) {
+    console.log("Git initialization failed or skipped.");
+  }
+}
+
+module.exports = {
+  createViteProject,
+  updatePackageJson,
+  installDependencies,
+  initializeShadcn,
+  initializeGit,
+};

package/templates/react-js/jsconfig.json

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

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

@@ -0,0 +1,56 @@
+/* eslint-disable react/prop-types */
+import { createContext, useState, useEffect } from "react";
+import DomoApi from "./DomoAPI";
+
+export const UserContext = createContext();
+
+export const UserProvider = ({ children }) => {
+  const [currentUser, setCurrentUser] = useState("");
+  const [currentUserId, setCurrentUserId] = useState("");
+  const [avatarKey, setAvatarKey] = useState("");
+  const [customer, setCustomer] = useState("");
+  const [host, setHost] = useState("");
+
+  useEffect(() => {
+    let isUserFetched = false;
+
+    DomoApi.GetCurrentUser().then((data) => {
+      // 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>
+  );
+};

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

@@ -0,0 +1,235 @@
+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);
+  }
+};