@reliverse/dler 1.7.91 → 1.7.93

package/bin/app/providers/better-t-stack/helpers/setup/tauri-setup.js

@@ -0,0 +1,67 @@
+import path from "node:path";
+import { re } from "@reliverse/relico";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { spinner } from "@reliverse/rempts";
+import { execa } from "execa";
+import { addPackageDependency } from "../../utils/add-package-deps.js";
+import { getPackageExecutionCommand } from "../../utils/get-package-execution-command.js";
+export async function setupTauri(config) {
+  const { packageManager, frontend, projectDir } = config;
+  const s = spinner({
+    text: "Setting up Tauri desktop app support..."
+  });
+  const clientPackageDir = path.join(projectDir, "apps/web");
+  if (!await fs.pathExists(clientPackageDir)) {
+    return;
+  }
+  try {
+    s.start("Setting up Tauri desktop app support...");
+    await addPackageDependency({
+      devDependencies: ["@tauri-apps/cli"],
+      projectDir: clientPackageDir
+    });
+    const clientPackageJsonPath = path.join(clientPackageDir, "package.json");
+    if (await fs.pathExists(clientPackageJsonPath)) {
+      const packageJson = await fs.readJson(clientPackageJsonPath);
+      packageJson.scripts = {
+        ...packageJson.scripts,
+        tauri: "tauri",
+        "desktop:dev": "tauri dev",
+        "desktop:build": "tauri build"
+      };
+      await fs.writeJson(clientPackageJsonPath, packageJson, { spaces: 2 });
+    }
+    const hasReactRouter = frontend.includes("react-router");
+    const hasNuxt = frontend.includes("nuxt");
+    const hasSvelte = frontend.includes("svelte");
+    const hasNext = frontend.includes("next");
+    const devUrl = hasReactRouter || hasSvelte ? "http://localhost:5173" : hasNext ? "http://localhost:3001" : "http://localhost:3001";
+    const frontendDist = hasNuxt ? "../.output/public" : hasSvelte ? "../build" : hasNext ? "../.next" : hasReactRouter ? "../build/client" : "../dist";
+    const tauriArgs = [
+      "init",
+      `--app-name=${path.basename(projectDir)}`,
+      `--window-title=${path.basename(projectDir)}`,
+      `--frontend-dist=${frontendDist}`,
+      `--dev-url=${devUrl}`,
+      `--before-dev-command="${packageManager} run dev"`,
+      `--before-build-command="${packageManager} run build"`
+    ];
+    const tauriArgsString = tauriArgs.join(" ");
+    const commandWithArgs = `@tauri-apps/cli@latest ${tauriArgsString}`;
+    const tauriInitCommand = getPackageExecutionCommand(packageManager, commandWithArgs);
+    await execa(tauriInitCommand, {
+      cwd: clientPackageDir,
+      env: {
+        CI: "true"
+      },
+      shell: true
+    });
+    s.stop("Tauri desktop app support configured successfully!");
+  } catch (error) {
+    s.stop(re.red("Failed to set up Tauri"));
+    if (error instanceof Error) {
+      relinka("error", error.message);
+    }
+  }
+}

package/bin/app/providers/better-t-stack/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@reliverse/rempts").Command<import("@reliverse/rempts").EmptyArgs>;
+export default _default;

package/bin/app/providers/better-t-stack/index.js

@@ -0,0 +1,282 @@
+import path from "node:path";
+import { re } from "@reliverse/relico";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import {
+  cancel,
+  createCli,
+  defineCommand,
+  intro,
+  isCancel,
+  outro,
+  selectPrompt,
+  spinner,
+  trpcServer,
+  zod as z
+} from "@reliverse/rempts";
+import { DEFAULT_CONFIG } from "./constants.js";
+import { createProject } from "./helpers/project-generation/create-project.js";
+import { gatherConfig } from "./prompts/config-prompts.js";
+import { getProjectName } from "./prompts/project-name.js";
+import {
+  AddonsSchema,
+  APISchema,
+  BackendSchema,
+  DatabaseSchema,
+  DatabaseSetupSchema,
+  ExamplesSchema,
+  FrontendSchema,
+  ORMSchema,
+  PackageManagerSchema,
+  ProjectNameSchema,
+  RuntimeSchema
+} from "./types.js";
+import { trackProjectCreation } from "./utils/analytics.js";
+import { displayConfig } from "./utils/display-config.js";
+import { generateReproducibleCommand } from "./utils/generate-reproducible-command.js";
+import { getLatestCLIVersion } from "./utils/get-latest-cli-version.js";
+import { openUrl } from "./utils/open-url.js";
+import { renderTitle } from "./utils/render-title.js";
+import { displaySponsors, fetchSponsors } from "./utils/sponsors.js";
+import { getProvidedFlags, processAndValidateFlags } from "./validation.js";
+const t = trpcServer.initTRPC.create();
+async function handleDirectoryConflict(currentPathInput) {
+  while (true) {
+    const resolvedPath = path.resolve(process.cwd(), currentPathInput);
+    const dirExists = fs.pathExistsSync(resolvedPath);
+    const dirIsNotEmpty = dirExists && fs.readdirSync(resolvedPath).length > 0;
+    if (!dirIsNotEmpty) {
+      return { finalPathInput: currentPathInput, shouldClearDirectory: false };
+    }
+    relinka("warn", `Directory "${re.yellow(currentPathInput)}" already exists and is not empty.`);
+    const action = await selectPrompt({
+      title: "What would you like to do?",
+      options: [
+        {
+          value: "overwrite",
+          label: "Overwrite",
+          hint: "Empty the directory and create the project"
+        },
+        {
+          value: "merge",
+          label: "Merge",
+          hint: "Create project files inside, potentially overwriting conflicts"
+        },
+        {
+          value: "rename",
+          label: "Choose a different name/path",
+          hint: "Keep the existing directory and create a new one"
+        },
+        { value: "cancel", label: "Cancel", hint: "Abort the process" }
+      ],
+      defaultValue: "rename"
+    });
+    if (isCancel(action)) {
+      cancel(re.red("Operation cancelled."));
+      process.exit(0);
+    }
+    switch (action) {
+      case "overwrite":
+        return { finalPathInput: currentPathInput, shouldClearDirectory: true };
+      case "merge":
+        relinka(
+          "info",
+          `Proceeding into existing directory "${re.yellow(
+            currentPathInput
+          )}". Files may be overwritten.`
+        );
+        return {
+          finalPathInput: currentPathInput,
+          shouldClearDirectory: false
+        };
+      case "rename": {
+        relinka("info", "Please choose a different project name or path.");
+        const newPathInput = await getProjectName(void 0);
+        return await handleDirectoryConflict(newPathInput);
+      }
+      case "cancel":
+        cancel(re.red("Operation cancelled."));
+        process.exit(0);
+    }
+  }
+}
+async function setupProjectDirectory(finalPathInput, shouldClearDirectory) {
+  let finalResolvedPath;
+  let finalBaseName;
+  if (finalPathInput === ".") {
+    finalResolvedPath = process.cwd();
+    finalBaseName = path.basename(finalResolvedPath);
+  } else {
+    finalResolvedPath = path.resolve(process.cwd(), finalPathInput);
+    finalBaseName = path.basename(finalResolvedPath);
+  }
+  if (shouldClearDirectory) {
+    const s = spinner({
+      text: `Clearing directory "${finalResolvedPath}"...`
+    });
+    s.start(`Clearing directory "${finalResolvedPath}"...`);
+    try {
+      await fs.emptyDir(finalResolvedPath);
+      s.stop(`Directory "${finalResolvedPath}" cleared.`);
+    } catch (error) {
+      s.stop(re.red(`Failed to clear directory "${finalResolvedPath}".`));
+      relinka("error", String(error));
+      process.exit(1);
+    }
+  } else {
+    await fs.ensureDir(finalResolvedPath);
+  }
+  return { finalResolvedPath, finalBaseName };
+}
+async function createProjectHandler(input) {
+  const startTime = Date.now();
+  try {
+    renderTitle();
+    intro(re.magenta("Creating a new Better-T Stack project"));
+    let currentPathInput;
+    if (input.yes && input.projectName) {
+      currentPathInput = input.projectName;
+    } else if (input.yes) {
+      let defaultName = DEFAULT_CONFIG.relativePath;
+      let counter = 1;
+      while (fs.pathExistsSync(path.resolve(process.cwd(), defaultName)) && fs.readdirSync(path.resolve(process.cwd(), defaultName)).length > 0) {
+        defaultName = `${DEFAULT_CONFIG.projectName}-${counter}`;
+        counter++;
+      }
+      currentPathInput = defaultName;
+    } else {
+      currentPathInput = await getProjectName(input.projectName);
+    }
+    const { finalPathInput, shouldClearDirectory } = await handleDirectoryConflict(currentPathInput);
+    const { finalResolvedPath, finalBaseName } = await setupProjectDirectory(
+      finalPathInput,
+      shouldClearDirectory
+    );
+    const cliInput = {
+      ...input,
+      projectDirectory: input.projectName
+    };
+    const providedFlags = getProvidedFlags(cliInput);
+    const flagConfig = processAndValidateFlags(cliInput, providedFlags, finalBaseName);
+    const { projectName: _projectNameFromFlags, ...otherFlags } = flagConfig;
+    if (!input.yes && Object.keys(otherFlags).length > 0) {
+      relinka("info", re.yellow("Using these pre-selected options:"));
+      relinka("log", displayConfig(otherFlags));
+      relinka("log", "");
+    }
+    let config;
+    if (input.yes) {
+      config = {
+        ...DEFAULT_CONFIG,
+        ...flagConfig,
+        projectName: finalBaseName,
+        projectDir: finalResolvedPath,
+        relativePath: finalPathInput
+      };
+      if (config.backend === "convex") {
+        relinka(
+          "info",
+          "Due to '--backend convex' flag, the following options have been automatically set: auth=false, database=none, orm=none, api=none, runtime=none, dbSetup=none, examples=todo"
+        );
+      } else if (config.backend === "none") {
+        relinka(
+          "info",
+          "Due to '--backend none', the following options have been automatically set: --auth=false, --database=none, --orm=none, --api=none, --runtime=none, --db-setup=none, --examples=none"
+        );
+      }
+      relinka("info", re.yellow("Using default/flag options (config prompts skipped):"));
+      relinka("log", displayConfig(config));
+      relinka("log", "");
+    } else {
+      config = await gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput);
+    }
+    await createProject(config);
+    const reproducibleCommand = generateReproducibleCommand(config);
+    relinka(
+      "success",
+      re.blue(`You can reproduce this setup with the following command:
+${reproducibleCommand}`)
+    );
+    await trackProjectCreation(config);
+    const elapsedTimeInSeconds = ((Date.now() - startTime) / 1e3).toFixed(2);
+    outro(re.magenta(`Project created successfully in ${re.bold(elapsedTimeInSeconds)} seconds!`));
+  } catch (error) {
+    relinka("error", String(error));
+    process.exit(1);
+  }
+}
+const router = t.router({
+  init: t.procedure.meta({
+    description: "Create a new Better-T Stack project",
+    default: true
+  }).input(
+    z.tuple([
+      ProjectNameSchema.optional(),
+      z.object({
+        yes: z.boolean().optional().default(false).describe("Use default configuration"),
+        database: DatabaseSchema.optional(),
+        orm: ORMSchema.optional(),
+        auth: z.boolean().optional(),
+        frontend: z.array(FrontendSchema).optional(),
+        addons: z.array(AddonsSchema).optional(),
+        examples: z.array(ExamplesSchema).optional(),
+        git: z.boolean().optional(),
+        packageManager: PackageManagerSchema.optional(),
+        install: z.boolean().optional(),
+        dbSetup: DatabaseSetupSchema.optional(),
+        backend: BackendSchema.optional(),
+        runtime: RuntimeSchema.optional(),
+        api: APISchema.optional()
+      }).optional().default({ yes: false })
+    ])
+  ).mutation(async ({ input }) => {
+    const [projectName, options] = input;
+    const combinedInput = {
+      projectName,
+      ...options
+    };
+    await createProjectHandler(combinedInput);
+  }),
+  sponsors: t.procedure.meta({ description: "Show Better-T Stack sponsors" }).mutation(async () => {
+    try {
+      renderTitle();
+      intro(re.magenta("Better-T Stack Sponsors"));
+      const sponsors = await fetchSponsors();
+      displaySponsors(sponsors);
+    } catch (error) {
+      relinka("error", String(error));
+      process.exit(1);
+    }
+  }),
+  docs: t.procedure.meta({ description: "Open Better-T Stack documentation" }).mutation(async () => {
+    const DOCS_URL = "https://better-t-stack.dev/docs";
+    try {
+      await openUrl(DOCS_URL);
+      relinka("success", re.blue("Opened docs in your default browser."));
+    } catch {
+      relinka("log", `Please visit ${DOCS_URL}`);
+    }
+  }),
+  builder: t.procedure.meta({ description: "Open the web-based stack builder" }).mutation(async () => {
+    const BUILDER_URL = "https://better-t-stack.dev/new";
+    try {
+      await openUrl(BUILDER_URL);
+      relinka("success", re.blue("Opened builder in your default browser."));
+    } catch {
+      relinka("log", `Please visit ${BUILDER_URL}`);
+    }
+  })
+});
+export default defineCommand({
+  router,
+  run() {
+    console.log("hello, world");
+  }
+});
+createCli({
+  name: "create-better-t-stack",
+  version: getLatestCLIVersion(),
+  rpc: {
+    router
+  }
+}).run();

package/bin/app/providers/better-t-stack/packed/addons.d.ts

@@ -0,0 +1,2 @@
+import type { Template } from "../better-t-stack-types.ts";
+export declare const DLER_TPL_ADDONS: Template;

package/bin/app/providers/better-t-stack/packed/addons.js

@@ -0,0 +1,263 @@
+export const DLER_TPL_ADDONS = {
+  name: "addons",
+  description: "Template generated from 12 files",
+  updatedAt: "2025-06-17T20:33:59.528Z",
+  config: {
+    files: {
+      "addons/biome/biome.json": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "0401c82b8b"
+        },
+        content: {
+          $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+          vcs: {
+            enabled: false,
+            clientKind: "git",
+            useIgnoreFile: false
+          },
+          files: {
+            ignoreUnknown: false,
+            ignore: [
+              ".next",
+              "dist",
+              ".turbo",
+              "dev-dist",
+              ".zed",
+              ".vscode",
+              "routeTree.gen.ts",
+              "src-tauri",
+              ".nuxt"
+            ]
+          },
+          formatter: {
+            enabled: true,
+            indentStyle: "tab"
+          },
+          organizeImports: {
+            enabled: true
+          },
+          linter: {
+            enabled: true,
+            rules: {
+              recommended: true,
+              correctness: {
+                useExhaustiveDependencies: "info"
+              },
+              nursery: {
+                useSortedClasses: {
+                  level: "warn",
+                  fix: "safe",
+                  options: {
+                    functions: ["clsx", "cva", "cn"]
+                  }
+                }
+              }
+            }
+          },
+          javascript: {
+            formatter: {
+              quoteStyle: "double"
+            }
+          }
+        },
+        type: "json"
+      },
+      "addons/husky/.husky/pre-commit": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "07ede6f4a9"
+        },
+        content: `lint-staged
+`,
+        type: "text"
+      },
+      "addons/pwa/apps/web/next/public/favicon/apple-touch-icon.png": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "b72f6b7339"
+        },
+        content: "",
+        type: "binary",
+        binaryHash: "b72f6b7339"
+      },
+      "addons/pwa/apps/web/next/public/favicon/favicon-96x96.png": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "01dad80fc2"
+        },
+        content: "",
+        type: "binary",
+        binaryHash: "01dad80fc2"
+      },
+      "addons/pwa/apps/web/next/public/favicon/favicon.svg": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "eda53e30fe"
+        },
+        content: "",
+        type: "binary",
+        binaryHash: "eda53e30fe"
+      },
+      "addons/pwa/apps/web/next/public/favicon/site.webmanifest.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "569a179bb9"
+        },
+        content: `{
+	"name": "{{projectName}}",
+	"short_name": "{{projectName}}",
+	"icons": [
+		{
+			"src": "/web-app-manifest-192x192.png",
+			"sizes": "192x192",
+			"type": "image/png",
+			"purpose": "maskable"
+		},
+		{
+			"src": "/web-app-manifest-512x512.png",
+			"sizes": "512x512",
+			"type": "image/png",
+			"purpose": "maskable"
+		}
+	],
+	"theme_color": "#ffffff",
+	"background_color": "#ffffff",
+	"display": "standalone"
+}
+`,
+        type: "text"
+      },
+      "addons/pwa/apps/web/next/public/favicon/web-app-manifest-192x192.png": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "2dc8b34485"
+        },
+        content: "",
+        type: "binary",
+        binaryHash: "2dc8b34485"
+      },
+      "addons/pwa/apps/web/next/public/favicon/web-app-manifest-512x512.png": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "dee83fc2fb"
+        },
+        content: "",
+        type: "binary",
+        binaryHash: "dee83fc2fb"
+      },
+      "addons/pwa/apps/web/next/src/app/manifest.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "6f8734ebe6"
+        },
+        content: `import type { MetadataRoute } from "next";
+export default function manifest(): MetadataRoute.Manifest {
+	return {
+		name: "{{projectName}}",
+		short_name: "{{projectName}}",
+		description:
+			"my pwa app",
+		start_url: "/new",
+		display: "standalone",
+		background_color: "#ffffff",
+		theme_color: "#000000",
+		icons: [
+			{
+				src: "/favicon/web-app-manifest-192x192.png",
+				sizes: "192x192",
+				type: "image/png",
+			},
+			{
+				src: "/favicon/web-app-manifest-512x512.png",
+				sizes: "512x512",
+				type: "image/png",
+			},
+		],
+	};
+}
+`,
+        type: "text"
+      },
+      "addons/pwa/apps/web/vite/public/logo.png": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "70aadde45a"
+        },
+        content: "",
+        type: "binary",
+        binaryHash: "70aadde45a"
+      },
+      "addons/pwa/apps/web/vite/pwa-assets.config.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "422e1dc3ac"
+        },
+        content: `import {
+  defineConfig,
+  minimal2023Preset as preset,
+} from "@vite-pwa/assets-generator/config";
+export default defineConfig({
+  headLinkOptions: {
+    preset: "2023",
+  },
+  preset,
+  images: ["public/logo.png"],
+});
+`,
+        type: "text"
+      },
+      "addons/turborepo/turbo.json.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "62f4fbd66c"
+        },
+        content: `{
+	"$schema": "https://turbo.build/schema.json",
+	"ui": "tui",
+	"tasks": {
+		"build": {
+			"dependsOn": ["^build"],
+			"inputs": ["$TURBO_DEFAULT$", ".env*"],
+			"outputs": ["dist/**"]
+		},
+		"lint": {
+			"dependsOn": ["^lint"]
+		},
+		"check-types": {
+			"dependsOn": ["^check-types"]
+		},
+		"dev": {
+			"cache": false,
+			"persistent": true
+		}{{#if (eq backend "convex")}},
+		"setup": {
+			"cache": false,
+			"persistent": true
+		}
+		{{else}}{{#unless (or (eq database "none") (eq orm "none"))}},
+		"db:push": {
+			"cache": false,
+			"persistent": true
+		},
+		"db:studio": {
+			"cache": false,
+			"persistent": true
+		},
+		"db:migrate": {
+			"cache": false,
+			"persistent": true
+		},
+		"db:generate": {
+			"cache": false,
+			"persistent": true
+		}
+		{{/unless}}{{/if}}
+	}
+}
+`,
+        type: "text"
+      }
+    }
+  }
+};

package/bin/app/providers/better-t-stack/packed/api.d.ts

@@ -0,0 +1,2 @@
+import type { Template } from "../better-t-stack-types.ts";
+export declare const DLER_TPL_API: Template;