create-vitnode-app 2.0.0-canary.1 → 2.0.0-canary.11

package/dist/src/helpers/init-vitnode.js

@@ -1,14 +1,13 @@
-import { spawn } from "node:child_process";
 import color from "picocolors";
+import { spawnCommand } from "./spawn-command.js";
 export const generateMigrationsVitnode = async ({ packageManager: pm, cwd, }) => {
     const packageManager = pm.split("@")[0];
     const args = ["vitnode", "migrate", "--generate"];
     await new Promise((resolve, reject) => {
         let output = "";
-        const child = spawn(packageManager, args, {
+        const child = spawnCommand(packageManager, args, {
             cwd,
             env: process.env,
-            shell: true,
             stdio: "pipe",
         });
         child.stdout?.on("data", (data) => {

package/dist/src/helpers/install-dependencies.js

@@ -1,6 +1,6 @@
-import { spawn } from "node:child_process";
 import consoleColor from "picocolors";
 import { getOnline } from "./is-online.js";
+import { spawnCommand } from "./spawn-command.js";
 function printInstallErrorSuggestions(stderr, color) {
     if (stderr.includes("ENOTFOUND") || stderr.includes("network")) {
         console.error(color.yellow("💡 Network error detected. Please check your internet connection."));
@@ -27,10 +27,9 @@ export const installDependencies = async ({ packageManager: pm, cwd, }) => {
     return new Promise((resolve, reject) => {
         let stdout = "";
         let stderr = "";
-        const child = spawn(packageManager, args, {
+        const child = spawnCommand(packageManager, args, {
             stdio: "pipe",
             cwd,
-            shell: true,
             env: {
                 ...process.env,
                 ADBLOCK: "1",

package/dist/src/helpers/spawn-command.js

@@ -0,0 +1,7 @@
+import { spawn } from "node:child_process";
+export const spawnCommand = (command, args = [], options = {}) => {
+    const spawnOptions = { ...options, shell: false };
+    return process.platform === "win32"
+        ? spawn("cmd.exe", ["/c", command, ...args], spawnOptions)
+        : spawn(command, args, spawnOptions);
+};

package/dist/src/index.js

@@ -35,6 +35,7 @@ const init = async () => {
     program.addOption(new Option("--package-manager <package-manager>", "Specify the package manager to use").choices(["npm", "pnpm", "bun"]));
     program.option("--eslint", "Initialize with ESLint & Prettier config.");
     program.option("--skip-install", "Skip installing packages after initializing the project.");
+    program.option("--skip-git", "Skip initializing a git repository in the project.");
     program.addOption(new Option("--mode <mode>", "What type of app do you want to create?").choices(["singleApp", "apiMonorepo", "onlyApi"]));
     program.option("--monorepo", "Create project with monorepo structure.");
     program.option("--docker", "Initialize with Docker support.");

package/dist/src/plugin/create/add-plugin-to-config.js

@@ -0,0 +1,231 @@
+import { readdir, readFile, writeFile } from "fs/promises";
+import { basename, dirname, join } from "path";
+import { pluginApiVariableName, pluginVariableName, } from "./route-templates.js";
+const SKIPPED_DIRECTORIES = new Set([
+    ".git",
+    ".next",
+    ".nitro",
+    ".output",
+    ".turbo",
+    ".vercel",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+]);
+const CONFIG_BUILDERS = {
+    "vitnode.api.config.ts": {
+        builder: "buildApiConfig",
+        subpath: "config.api",
+    },
+    "vitnode.config.ts": { builder: "buildConfig", subpath: "config" },
+};
+const endOfStringLiteral = (source, start) => {
+    const quote = source[start];
+    let index = start + 1;
+    while (index < source.length) {
+        const char = source[index];
+        if (char === "\\") {
+            index += 2;
+            continue;
+        }
+        if (char === quote)
+            return index + 1;
+        index += 1;
+    }
+    return source.length;
+};
+const closingBracketOf = (source, open) => {
+    let depth = 0;
+    let index = open;
+    while (index < source.length) {
+        const char = source[index];
+        if (char === "/" && source[index + 1] === "/") {
+            const newline = source.indexOf("\n", index);
+            index = newline === -1 ? source.length : newline;
+            continue;
+        }
+        if (char === "/" && source[index + 1] === "*") {
+            const end = source.indexOf("*/", index + 2);
+            index = end === -1 ? source.length : end + 2;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            index = endOfStringLiteral(source, index);
+            continue;
+        }
+        if (char === "[" || char === "(" || char === "{") {
+            depth += 1;
+        }
+        else if (char === "]" || char === ")" || char === "}") {
+            depth -= 1;
+            if (depth === 0)
+                return char === "]" ? index : -1;
+        }
+        index += 1;
+    }
+    return -1;
+};
+const findPluginsArray = (source, from) => {
+    const key = /\bplugins\s*:\s*\[/g;
+    key.lastIndex = from;
+    const match = key.exec(source);
+    if (!match)
+        return null;
+    const open = match.index + match[0].length - 1;
+    const close = closingBracketOf(source, open);
+    return close === -1 ? null : { close, open };
+};
+const readImports = (source) => {
+    const statements = [];
+    let offset = 0;
+    let open = null;
+    for (const line of source.split("\n")) {
+        const lineStart = offset;
+        offset += line.length + 1;
+        open ??= /^import\b/.test(line)
+            ? { isType: /^import\s+type\b/.test(line), start: lineStart }
+            : null;
+        if (!open)
+            continue;
+        const specifier = /\bfrom\s+['"]([^'"]+)['"]/.exec(line)?.[1] ??
+            /^import\s+['"]([^'"]+)['"]/.exec(line)?.[1];
+        if (specifier === undefined)
+            continue;
+        const end = lineStart + line.length;
+        statements.push({
+            end,
+            isType: open.isType,
+            specifier,
+            start: open.start,
+            text: source.slice(open.start, end),
+        });
+        open = null;
+    }
+    return statements;
+};
+const importStyleOf = (source) => {
+    const match = /\bfrom\s+(['"])[^'"\n]+\1(;?)/.exec(source);
+    return { quote: match?.[1] ?? '"', semicolon: match?.[2] ?? ";" };
+};
+const withImport = (source, { factory, module }) => {
+    const { quote, semicolon } = importStyleOf(source);
+    const statement = `import { ${factory} } from ${quote}${module}${quote}${semicolon}`;
+    const imports = readImports(source);
+    if (imports.length === 0) {
+        return `${statement}\n\n${source}`;
+    }
+    const before = imports.find(entry => !entry.isType && entry.specifier > module);
+    if (before) {
+        return `${source.slice(0, before.start)}${statement}\n${source.slice(before.start)}`;
+    }
+    const last = imports[imports.length - 1];
+    return `${source.slice(0, last.end)}\n${statement}${source.slice(last.end)}`;
+};
+const withEntry = (source, { close, open }, call) => {
+    const body = source.slice(open + 1, close);
+    const head = source.slice(0, open + 1);
+    const tail = source.slice(close);
+    if (body.trim() === "") {
+        if (!body.includes("\n"))
+            return `${head}${call}${tail}`;
+        const indent = /\n([ \t]*)$/.exec(body)?.[1] ?? "";
+        return `${head}\n${indent}  ${call},${body}${tail}`;
+    }
+    if (!body.includes("\n")) {
+        const separator = body.trimEnd().endsWith(",") ? " " : ", ";
+        return `${head}${body}${separator}${call}${tail}`;
+    }
+    const entries = body.trimEnd();
+    const trailing = body.slice(entries.length);
+    const indent = /^[ \t]*(?=\S)/m.exec(body.slice(body.indexOf("\n") + 1))?.[0] ?? "  ";
+    const comma = entries.endsWith(",") ? "" : ",";
+    return `${head}${entries}${comma}\n${indent}${call},${trailing}${tail}`;
+};
+export const registerPluginInSource = (source, { builder, factory, module }) => {
+    const builderAt = source.indexOf(`${builder}(`);
+    if (builderAt === -1)
+        return { source, status: "no-config-call" };
+    const range = findPluginsArray(source, builderAt);
+    if (!range)
+        return { source, status: "no-plugins-array" };
+    const called = new RegExp(`\\b${factory}\\s*\\(`);
+    const hasEntry = called.test(source.slice(range.open + 1, range.close));
+    const hasImport = readImports(source).some(entry => entry.specifier === module &&
+        new RegExp(`\\b${factory}\\b`).test(entry.text));
+    if (hasEntry && hasImport)
+        return { source, status: "already-registered" };
+    const withCall = hasEntry ? source : withEntry(source, range, `${factory}()`);
+    return {
+        source: hasImport ? withCall : withImport(withCall, { factory, module }),
+        status: "registered",
+    };
+};
+const readEntries = async (dir) => {
+    try {
+        return await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+};
+const findConfigFiles = async (dir, skipDir, results = []) => {
+    for (const entry of await readEntries(dir)) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (SKIPPED_DIRECTORIES.has(entry.name) || fullPath === skipDir)
+                continue;
+            await findConfigFiles(fullPath, skipDir, results);
+            continue;
+        }
+        if (entry.isFile() && CONFIG_BUILDERS[entry.name]) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+};
+const ownedByVitNodePackage = async (file, rootPath) => {
+    let current = dirname(file);
+    while (current.startsWith(rootPath)) {
+        try {
+            const pkg = JSON.parse(await readFile(join(current, "package.json"), "utf-8"));
+            return Boolean(pkg.dependencies?.["@vitnode/core"] ??
+                pkg.devDependencies?.["@vitnode/core"]);
+        }
+        catch {
+            const parent = dirname(current);
+            if (parent === current)
+                return false;
+            current = parent;
+        }
+    }
+    return false;
+};
+export const addPluginToConfig = async ({ pluginName, pluginPath, rootPath, }) => {
+    const files = await findConfigFiles(rootPath, pluginPath);
+    const registrations = [];
+    for (const file of files.sort()) {
+        if (!(await ownedByVitNodePackage(file, rootPath)))
+            continue;
+        const target = CONFIG_BUILDERS[basename(file)];
+        const isApi = target.subpath === "config.api";
+        try {
+            const source = await readFile(file, "utf-8");
+            const { source: next, status } = registerPluginInSource(source, {
+                builder: target.builder,
+                factory: isApi
+                    ? pluginApiVariableName(pluginName)
+                    : pluginVariableName(pluginName),
+                module: `${pluginName}/${target.subpath}`,
+            });
+            if (status === "registered") {
+                await writeFile(file, next, "utf-8");
+            }
+            registrations.push({ file, status });
+        }
+        catch {
+            continue;
+        }
+    }
+    return registrations;
+};

package/dist/src/plugin/create/create-package-json.js

@@ -4,6 +4,15 @@ import { getVitnodePackageVersion } from "../../helpers/get-vitnode-package-vers
 import { withIf } from "../../helpers/with-If.js";
 import { pluginPackageExports } from "./route-templates.js";
 const writeJson = async (path, data) => writeFile(path, JSON.stringify(data, null, 2));
+export const pluginScripts = (eslint) => ({
+    "build:plugins": "vitnode build",
+    dev: "vitnode dev",
+    "dev:email": "email dev --dir src/emails",
+    ...withIf(eslint, {
+        lint: "turbo lint",
+        "lint:fix": "turbo lint:fix",
+    }),
+});
 export const createPluginPackageJSON = async ({ pluginName, pluginPath, eslint, }) => {
     const vitnodeVersionRange = await getVitnodePackageVersion();
     const pluginPkg = {
@@ -11,18 +20,11 @@ export const createPluginPackageJSON = async ({ pluginName, pluginPath, eslint,
         version: "0.1.0",
         private: true,
         type: "module",
-        scripts: {
-            "build:plugins": "vitnode build",
-            dev: "vitnode dev",
-            "dev:email": "email dev --dir src/emails",
-            ...withIf(eslint, {
-                lint: "turbo lint",
-                "lint:fix": "turbo lint:fix",
-            }),
-        },
+        scripts: pluginScripts(eslint),
         exports: pluginPackageExports(),
         dependencies: {
             "@hono/zod-openapi": versionsPackageJson.honoZodOpenapi,
+            "@tanstack/react-form": versionsPackageJson.tanstackReactForm,
             "@vitnode/core": vitnodeVersionRange,
             "drizzle-kit": versionsPackageJson.drizzleKit,
             "drizzle-orm": versionsPackageJson.drizzleOrm,
@@ -31,7 +33,6 @@ export const createPluginPackageJSON = async ({ pluginName, pluginPath, eslint,
             react: versionsPackageJson.react,
             "react-dom": versionsPackageJson.reactDom,
             "react-email": versionsPackageJson.reactEmail,
-            "react-hook-form": versionsPackageJson.rhf,
             sonner: versionsPackageJson.sonner,
             "use-intl": versionsPackageJson.useIntl,
             zod: versionsPackageJson.zod,
@@ -43,6 +44,7 @@ export const createPluginPackageJSON = async ({ pluginName, pluginPath, eslint,
             "@types/react": versionsPackageJson.typesReact,
             "@types/react-dom": versionsPackageJson.typesReactDom,
             "@vitnode/config": vitnodeVersionRange,
+            cn: versionsPackageJson.cn,
             ...withIf(eslint, {
                 eslint: versionsPackageJson.eslint,
             }),

package/dist/src/plugin/create/create-plugin-vitnode.js

@@ -1,12 +1,13 @@
 import { existsSync } from "fs";
 import { cp, mkdir, rename, writeFile } from "fs/promises";
 import ora from "ora";
-import { dirname, join } from "path";
+import { dirname, join, relative } from "path";
 import color from "picocolors";
 import { fileURLToPath } from "url";
 import { getPackageManagerFromRoot } from "../../helpers/get-package-manager-from-root.js";
 import { installDependencies } from "../../helpers/install-dependencies.js";
 import { isFolderEmpty } from "../../helpers/is-folder-empty.js";
+import { addPluginToConfig } from "./add-plugin-to-config.js";
 import { addPluginToWorkspace } from "./add-plugin-to-workspace.js";
 import { createPluginPackageJSON } from "./create-package-json.js";
 import { pluginRouteScaffold } from "./route-templates.js";
@@ -15,6 +16,19 @@ const writePluginRouteScaffold = async ({ pluginName, pluginPath, }) => {
     await Promise.all(Object.keys(files).map(async (file) => mkdir(dirname(join(pluginPath, file)), { recursive: true })));
     await Promise.all(Object.entries(files).map(async ([file, contents]) => writeFile(join(pluginPath, file), contents, "utf-8")));
 };
+const reportConfigRegistrations = ({ pluginName, registrations, rootPath, }) => {
+    const registered = registrations.filter(({ status }) => status === "registered");
+    registered.forEach(({ file }) => {
+        console.log(`  ${color.green("+")} Registered in ${color.cyan(relative(rootPath, file))}`);
+    });
+    const unusable = registrations.filter(({ status }) => status === "no-plugins-array");
+    unusable.forEach(({ file }) => {
+        console.log(`  ${color.yellow("!")} ${color.cyan(relative(rootPath, file))} has no \`plugins\` array - add ${color.cyan(pluginName)} to it by hand.`);
+    });
+    if (registered.length === 0 && unusable.length === 0) {
+        console.log(`  ${color.yellow("!")} No VitNode config found. Add ${color.cyan(`${pluginName}/config`)} to your app's \`vitnode.config.ts\` and ${color.cyan(`${pluginName}/config.api`)} to its \`vitnode.api.config.ts\`.`);
+    }
+};
 export const createPluginVitNode = async ({ pluginPath, pluginName, install, eslint, }) => {
     const packageManager = getPackageManagerFromRoot(process.cwd());
     const spinner = ora(`Creating a new VitNode plugin in ${color.green(pluginPath)}. Using ${color.green(packageManager)}...`).start();
@@ -36,7 +50,7 @@ export const createPluginVitNode = async ({ pluginPath, pluginName, install, esl
     if (existsSync(npmIgnoreTemplatePath)) {
         await rename(npmIgnoreTemplatePath, dotNpmIgnorePath);
     }
-    spinner.text = "Writing the plugin's first route...";
+    spinner.text = "Writing the plugin's first route and API...";
     await writePluginRouteScaffold({ pluginName, pluginPath });
     spinner.text = "Creating package.json...";
     await createPluginPackageJSON({
@@ -69,6 +83,12 @@ export const createPluginVitNode = async ({ pluginPath, pluginName, install, esl
         pluginPath,
         rootPath,
     });
+    spinner.text = "Registering the plugin with the apps that can serve it...";
+    const registrations = await addPluginToConfig({
+        pluginName,
+        pluginPath,
+        rootPath,
+    });
     if (install) {
         spinner.text = "Installing dependencies...";
         await installDependencies({
@@ -77,4 +97,5 @@ export const createPluginVitNode = async ({ pluginPath, pluginName, install, esl
         });
     }
     spinner.succeed(`${color.green("Success!")} Created ${color.cyan(pluginName)} at ${color.cyan(pluginPath)}`);
+    reportConfigRegistrations({ pluginName, registrations, rootPath });
 };

package/dist/src/plugin/create/route-templates.js

@@ -1,27 +1,14 @@
 export const routeSlugFor = (pluginName) => pluginName.includes("/")
     ? pluginName.slice(pluginName.indexOf("/") + 1)
     : pluginName;
+export const pluginConstTemplate = (pluginName) => `export const CONFIG_PLUGIN = {
+  pluginId: "${pluginName}" as const,
+};
+`;
 export const pluginRoutesTemplate = (pluginName) => {
     const slug = routeSlugFor(pluginName);
     return `import { definePluginRoutes, lazy, page } from "@vitnode/core/routing";
 
-/**
- * The routes this plugin contributes to whatever app installs it.
- *
- * Browser-safe data: a path, and the module that renders it. \`lazy\` keeps that
- * \`import()\` a literal the bundler can follow *without running it*, so your page
- * gets a chunk of its own and is fetched when somebody navigates to it - not
- * before. Never import a page into this file: a component named here is in the
- * initial bundle of every page on the site, which is why VitNode refuses one.
- *
- * Your page is never copied into the application either. The app holds one static
- * import of this tree, and nothing else.
- *
- * Add a route by adding a \`page()\`. \`path\` is the public URL, written in
- * VitNode's own spelling: a dynamic segment is \`:id\`, never Next's \`[id]\` and
- * never TanStack's \`$id\`. To nest pages inside a shared frame, wrap them in a
- * \`layout()\` and give each child a path relative to it.
- */
 export const routes = definePluginRoutes([
   page("/${slug}", {
     component: lazy(() => import("./pages/home-page")),
@@ -29,33 +16,30 @@ export const routes = definePluginRoutes([
 ]);
 `;
 };
-export const pluginRouteModuleTemplate = (pluginName) => `import { useTranslations } from "use-intl";
-
-/**
- * The page \`routes.ts\` declares.
- *
- * Keep it framework-neutral. This module is compiled into the package's own
- * \`dist\` and imported by whichever app installed the plugin, so anything from
- * a router or a host-bound i18n package pins the plugin to one kind of host.
- * \`use-intl\` - which is what VitNode itself renders through - and plain JSX are
- * pinned to neither.
- *
- * No \`<main>\`: the application shell owns the document's one \`main\` landmark,
- * and a page that renders a second gives a screen reader two to choose between.
- * A page owns its container - width, padding, vertical rhythm - and nothing
- * above it.
- *
- * To give this route a loader, page metadata or a breadcrumb, add a \`route\`
- * export beside the default one:
- *
- *     import { definePluginRoute } from "@vitnode/core/routing";
- *
- *     export const route = definePluginRoute({
- *       load: ({ context, params }) => fetchThing(context.locale, params.id),
- *       head: ({ loaderData }) => ({ title: loaderData?.title }),
- *     });
- */
-const HomePage = () => {
+export const pluginRouteModuleTemplate = (pluginName) => `import type { PluginRoutePageProps } from "@vitnode/core/routing";
+
+import { definePluginRoute } from "@vitnode/core/routing";
+import { useTranslations } from "use-intl";
+
+import { helloApi } from "@/api/client";
+
+interface HelloMessage {
+  message: string;
+}
+
+export const route = definePluginRoute<HelloMessage>({
+  load: async () => {
+    const response = await helloApi.fetch({
+      method: "get",
+      module: "hello",
+      path: "/",
+    });
+
+    return await response.json();
+  },
+});
+
+const HomePage = ({ loaderData }: PluginRoutePageProps<HelloMessage>) => {
   const t = useTranslations("${pluginName}");
 
   return (
@@ -67,6 +51,11 @@ const HomePage = () => {
       <p className="text-muted-foreground leading-relaxed text-pretty">
         {t("home.desc")}
       </p>
+
+      <div className="bg-card text-card-foreground flex flex-col gap-1 rounded-lg border p-4">
+        <span className="text-muted-foreground text-sm">{t("home.api")}</span>
+        <span className="font-medium">{loaderData.message}</span>
+      </div>
     </div>
   );
 };
@@ -76,6 +65,7 @@ export default HomePage;
 export const pluginMessagesTemplate = (pluginName) => `${JSON.stringify({
     [pluginName]: {
         home: {
+            api: "Your plugin's API answered:",
             desc: "This page ships inside the plugin and is served by the app that installed it.",
             title: "Hello from your plugin",
         },
@@ -83,11 +73,6 @@ export const pluginMessagesTemplate = (pluginName) => `${JSON.stringify({
 }, null, 2)}\n`;
 export const pluginMessagesBarrelTemplate = () => `import type { LocaleMessagesMap } from "@vitnode/core/lib/i18n/types";
 
-/**
- * Every language this plugin ships. Add a file next to this one and a line here
- * to add another; apps pick it up with no copy step, because they read this
- * package's own \`dist\` rather than a copy of it.
- */
 const messages: LocaleMessagesMap = {
   en: async () => await import("./en.json", { with: { type: "json" } }),
 };
@@ -106,27 +91,79 @@ export const pluginVariableName = (pluginName) => {
 };
 export const pluginConfigTemplate = (pluginName) => `import { buildPlugin } from "@vitnode/core/lib/plugin";
 
+import { CONFIG_PLUGIN } from "@/const";
+
 import messages from "./locales";
 import { routes } from "./routes";
 
-/**
- * This plugin, as an application registers it.
- *
- * \`pluginId\` is the package name, and that is not a convention - it is how this
- * plugin's route tree is imported (\`${pluginName}/routes\`) and how its messages
- * are namespaced. The two cannot drift because they are one string.
- *
- * Add this to an app's \`src/vitnode.config.ts\` \`plugins\` array. A plugin that
- * is installed but not listed there contributes nothing - no directory is ever
- * scanned - so this is the only switch.
- */
 export const ${pluginVariableName(pluginName)} = () =>
   buildPlugin({
-    pluginId: "${pluginName}",
+    pluginId: CONFIG_PLUGIN.pluginId,
     messages,
     routes,
   });
 `;
+export const pluginApiVariableName = (pluginName) => pluginVariableName(pluginName).replace(/Plugin$/, "ApiPlugin");
+export const pluginApiRouteTemplate = () => `import { z } from "@hono/zod-openapi";
+import { buildRoute } from "@vitnode/core/api/lib/route";
+
+import { CONFIG_PLUGIN } from "@/const";
+
+export const helloRoute = buildRoute({
+  pluginId: CONFIG_PLUGIN.pluginId,
+  route: {
+    method: "get",
+    path: "/",
+    responses: {
+      200: {
+        content: {
+          "application/json": {
+            schema: z.object({ message: z.string() }),
+          },
+        },
+        description: "A greeting from the plugin.",
+      },
+    },
+  },
+  handler: c => c.json({ message: \`Hello from \${CONFIG_PLUGIN.pluginId}!\` }),
+});
+`;
+export const pluginApiModuleTemplate = () => `import { buildModule } from "@vitnode/core/api/lib/module";
+
+import { CONFIG_PLUGIN } from "@/const";
+
+import { helloRoute } from "./hello.route";
+
+export const helloModule = buildModule({
+  pluginId: CONFIG_PLUGIN.pluginId,
+  name: "hello",
+  routes: [helloRoute],
+});
+`;
+export const pluginApiClientTemplate = () => `import type { ApiClient } from "@vitnode/core/tanstack/fetcher";
+
+import { createApiClient } from "@vitnode/core/tanstack/fetcher";
+
+import type { helloModule } from "@/api/modules/hello/hello.module";
+
+import { CONFIG_PLUGIN } from "@/const";
+
+export const helloApi: ApiClient<typeof helloModule> = createApiClient<
+  typeof helloModule
+>(CONFIG_PLUGIN.pluginId);
+`;
+export const pluginApiConfigTemplate = (pluginName) => `import { buildApiPlugin } from "@vitnode/core/api/lib/plugin";
+
+import { CONFIG_PLUGIN } from "@/const";
+
+import { helloModule } from "./api/modules/hello/hello.module";
+
+export const ${pluginApiVariableName(pluginName)} = () =>
+  buildApiPlugin({
+    pluginId: CONFIG_PLUGIN.pluginId,
+    modules: [helloModule],
+  });
+`;
 export const pluginPackageExports = () => ({
     "./locales/*.json": "./src/locales/*.json",
     "./*": {
@@ -136,7 +173,12 @@ export const pluginPackageExports = () => ({
     },
 });
 export const pluginRouteScaffold = (pluginName) => ({
+    "src/api/client.ts": pluginApiClientTemplate(),
+    "src/api/modules/hello/hello.module.ts": pluginApiModuleTemplate(),
+    "src/api/modules/hello/hello.route.ts": pluginApiRouteTemplate(),
+    "src/config.api.ts": pluginApiConfigTemplate(pluginName),
     "src/config.tsx": pluginConfigTemplate(pluginName),
+    "src/const.ts": pluginConstTemplate(pluginName),
     "src/locales/en.json": pluginMessagesTemplate(pluginName),
     "src/locales/index.ts": pluginMessagesBarrelTemplate(),
     "src/pages/home-page.tsx": pluginRouteModuleTemplate(pluginName),

package/dist/src/questions.js

@@ -6,6 +6,7 @@ export const createQuestionsCli = async (program) => {
     const options = {
         packageManager: optionsFromProgram.packageManager,
         eslint: optionsFromProgram.eslint,
+        git: !optionsFromProgram.skipGit,
         install: !optionsFromProgram.skipInstall,
         docker: optionsFromProgram.docker,
         mode: optionsFromProgram.mode,
@@ -74,6 +75,12 @@ export const createQuestionsCli = async (program) => {
             message: `Would you like to use ${color.blue("Docker Container")}?`,
         });
     }
+    if (optionsFromProgram.skipGit === undefined) {
+        options.git = await confirm({
+            message: `Would you like to initialize a ${color.blue("Git repository")}?`,
+            default: true,
+        });
+    }
     if (optionsFromProgram.skipInstall === undefined) {
         options.install = await confirm({
             message: `Would you like to ${color.blue("Install dependencies")}?`,