tvi-cli 0.1.4

package/templates/backend/convex/packages/backend/convex/README.md

@@ -0,0 +1,90 @@
+# Welcome to your Convex functions directory!
+
+Write your Convex functions here.
+See https://docs.convex.dev/functions for more.
+
+A query function that takes two arguments looks like:
+
+```ts
+// functions.js
+import { query } from "./_generated/server";
+import { v } from "convex/values";
+
+export const myQueryFunction = query({
+  // Validators for arguments.
+  args: {
+    first: v.number(),
+    second: v.string(),
+  },
+
+  // Function implementation.
+  handler: async (ctx, args) => {
+    // Read the database as many times as you need here.
+    // See https://docs.convex.dev/database/reading-data.
+    const documents = await ctx.db.query("tablename").collect();
+
+    // Arguments passed from the client are properties of the args object.
+    console.log(args.first, args.second);
+
+    // Write arbitrary JavaScript here: filter, aggregate, build derived data,
+    // remove non-public properties, or create new objects.
+    return documents;
+  },
+});
+```
+
+Using this query function in a React component looks like:
+
+```ts
+const data = useQuery(api.functions.myQueryFunction, {
+  first: 10,
+  second: "hello",
+});
+```
+
+A mutation function looks like:
+
+```ts
+// functions.js
+import { mutation } from "./_generated/server";
+import { v } from "convex/values";
+
+export const myMutationFunction = mutation({
+  // Validators for arguments.
+  args: {
+    first: v.string(),
+    second: v.string(),
+  },
+
+  // Function implementation.
+  handler: async (ctx, args) => {
+    // Insert or modify documents in the database here.
+    // Mutations can also read from the database like queries.
+    // See https://docs.convex.dev/database/writing-data.
+    const message = { body: args.first, author: args.second };
+    const id = await ctx.db.insert("messages", message);
+
+    // Optionally, return a value from your mutation.
+    return await ctx.db.get(id);
+  },
+});
+```
+
+Using this mutation function in a React component looks like:
+
+```ts
+const mutation = useMutation(api.functions.myMutationFunction);
+function handleButtonPress() {
+  // fire and forget, the most common way to use mutations
+  mutation({ first: "Hello!", second: "me" });
+  // OR
+  // use the result once the mutation has completed
+  mutation({ first: "Hello!", second: "me" }).then((result) =>
+    console.log(result),
+  );
+}
+```
+
+Use the Convex CLI to push your functions to a deployment. See everything
+the Convex CLI can do by running `npx convex -h` in your project root
+directory. To learn more, launch the docs with `npx convex docs`.

package/templates/backend/convex/packages/backend/convex/healthCheck.ts

@@ -0,0 +1,7 @@
+import { query } from "./_generated/server";
+
+export const get = query({
+  handler: async () => {
+    return "OK";
+  }
+})

package/templates/backend/convex/packages/backend/convex/schema.ts

@@ -0,0 +1,9 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export default defineSchema({
+  todos: defineTable({
+    text: v.string(),
+    completed: v.boolean(),
+  }),
+});

package/templates/backend/convex/packages/backend/convex/todos.ts

@@ -0,0 +1,42 @@
+import { query, mutation } from "./_generated/server";
+import { v } from "convex/values";
+
+export const getAll = query({
+  handler: async (ctx) => {
+    return await ctx.db.query("todos").collect();
+  },
+});
+
+export const create = mutation({
+  args: {
+    text: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const newTodoId = await ctx.db.insert("todos", {
+      text: args.text,
+      completed: false,
+    });
+    return await ctx.db.get(newTodoId);
+  },
+});
+
+export const toggle = mutation({
+  args: {
+    id: v.id("todos"),
+    completed: v.boolean(),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.id, { completed: args.completed });
+    return { success: true };
+  },
+});
+
+export const deleteTodo = mutation({
+  args: {
+    id: v.id("todos"),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.id);
+    return { success: true };
+  },
+});

package/templates/backend/convex/packages/backend/convex/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  /* This TypeScript project config describes the environment that
+   * Convex functions run in and is used to typecheck them.
+   * You can modify it, but some settings required to use Convex.
+   */
+  "compilerOptions": {
+    /* These settings are not required by Convex and can be modified. */
+    "allowJs": true,
+    "strict": true,
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+
+    /* These compiler options are required by Convex */
+    "target": "ESNext",
+    "lib": ["ES2021", "dom"],
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "isolatedModules": true,
+    "noEmit": true
+  },
+  "include": ["./**/*"],
+  "exclude": ["./_generated"]
+}

package/templates/backend/convex/packages/backend/package.json.hbs

@@ -0,0 +1,17 @@
+{
+  "name": "@{{projectName}}/backend",
+  "version": "1.0.0",
+  "scripts": {
+    "dev": "convex dev",
+    "setup": "convex dev --configure --until-success"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "convex": "^1.23.0"
+  }
+}

package/templates/backend/server/elysia/src/index.ts.hbs

@@ -0,0 +1,72 @@
+import "dotenv/config";
+{{#if (eq runtime "node")}}
+import { node } from "@elysiajs/node";
+{{/if}}
+import { Elysia } from "elysia";
+import { cors } from "@elysiajs/cors";
+{{#if (eq api "trpc")}}
+import { createContext } from "./lib/context";
+import { appRouter } from "./routers/index";
+import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
+{{/if}}
+{{#if (eq api "orpc")}}
+import { RPCHandler } from "@orpc/server/fetch";
+import { appRouter } from "./routers";
+import { createContext } from "./lib/context";
+{{/if}}
+{{#if auth}}
+import { auth } from "./lib/auth";
+{{/if}}
+
+{{#if (eq api "orpc")}}
+const handler = new RPCHandler(appRouter);
+{{/if}}
+
+{{#if (eq runtime "node")}}
+const app = new Elysia({ adapter: node() })
+{{else}}
+const app = new Elysia()
+{{/if}}
+  .use(
+    cors({
+      origin: process.env.CORS_ORIGIN || "",
+      methods: ["GET", "POST", "OPTIONS"],
+      {{#if auth}}
+      allowedHeaders: ["Content-Type", "Authorization"],
+      credentials: true,
+      {{/if}}
+    }),
+  )
+  {{#if auth}}
+  .all("/api/auth/*", async (context) => {
+    const { request } = context;
+    if (["POST", "GET"].includes(request.method)) {
+      return auth.handler(request);
+    }
+    context.error(405);
+  })
+  {{/if}}
+{{#if (eq api "orpc")}}
+  .all('/rpc*', async (context) => {
+    const { response } = await handler.handle(context.request, {
+      prefix: '/rpc',
+      context: await createContext({ context })
+    })
+    return response ?? new Response('Not Found', { status: 404 })
+  })
+{{/if}}
+{{#if (eq api "trpc")}}
+  .all("/trpc/*", async (context) => {
+    const res = await fetchRequestHandler({
+      endpoint: "/trpc",
+      router: appRouter,
+      req: context.request,
+      createContext: () => createContext({ context }),
+    });
+    return res;
+  })
+{{/if}}
+  .get("/", () => "OK")
+  .listen(3000, () => {
+    console.log("Server is running on http://localhost:3000");
+  });

package/templates/backend/server/express/src/index.ts.hbs

@@ -0,0 +1,88 @@
+import "dotenv/config";
+{{#if (eq api "trpc")}}
+import { createExpressMiddleware } from "@trpc/server/adapters/express";
+import { createContext } from "./lib/context";
+import { appRouter } from "./routers/index";
+{{/if}}
+{{#if (eq api "orpc")}}
+import { RPCHandler } from "@orpc/server/node";
+import { appRouter } from "./routers";
+{{#if auth}}
+import { createContext } from "./lib/context";
+{{/if}}
+{{/if}}
+import cors from "cors";
+import express from "express";
+{{#if (includes examples "ai")}}
+import { streamText } from "ai";
+import { google } from "@ai-sdk/google";
+{{/if}}
+{{#if auth}}
+import { auth } from "./lib/auth";
+import { toNodeHandler } from "better-auth/node";
+{{/if}}
+
+const app = express();
+
+app.use(
+  cors({
+    origin: process.env.CORS_ORIGIN || "",
+    methods: ["GET", "POST", "OPTIONS"],
+    {{#if auth}}
+    allowedHeaders: ["Content-Type", "Authorization"],
+    credentials: true,
+    {{/if}}
+  })
+);
+
+{{#if auth}}
+app.all("/api/auth{/*path}", toNodeHandler(auth));
+{{/if}}
+
+{{#if (eq api "trpc")}}
+app.use(
+  "/trpc",
+  createExpressMiddleware({
+    router: appRouter,
+    createContext
+  })
+);
+{{/if}}
+
+{{#if (eq api "orpc")}}
+const handler = new RPCHandler(appRouter);
+app.use('/rpc{*path}', async (req, res, next) => {
+  const { matched } = await handler.handle(req, res, {
+    prefix: '/rpc',
+    {{#if auth}}
+    context: await createContext({ req }),
+    {{else}}
+    context: {},
+    {{/if}}
+  });
+  if (matched) return;
+  next();
+});
+{{/if}}
+
+app.use(express.json())
+
+{{#if (includes examples "ai")}}
+app.post("/ai", async (req, res) => {
+  const { messages = [] } = req.body || {};
+  const result = streamText({
+    model: google("gemini-1.5-flash"),
+    messages,
+  });
+  result.pipeDataStreamToResponse(res);
+});
+{{/if}}
+
+app.get("/", (_req, res) => {
+  res.status(200).send("OK");
+});
+
+const port = process.env.PORT || 3000;
+app.listen(port, () => {
+  console.log(`Server is running on port ${port}`);
+});

package/templates/backend/server/fastify/src/index.ts.hbs

@@ -0,0 +1,155 @@
+import "dotenv/config";
+import Fastify from "fastify";
+import fastifyCors from "@fastify/cors";
+
+{{#if (eq api "trpc")}}
+import { fastifyTRPCPlugin, type FastifyTRPCPluginOptions } from "@trpc/server/adapters/fastify";
+import { createContext } from "./lib/context";
+import { appRouter, type AppRouter } from "./routers/index";
+{{/if}}
+
+{{#if (eq api "orpc")}}
+import { RPCHandler } from "@orpc/server/node";
+import { CORSPlugin } from "@orpc/server/plugins";
+import { appRouter } from "./routers/index";
+import { createServer } from "node:http";
+{{#if auth}}
+import { createContext } from "./lib/context";
+{{/if}}
+{{/if}}
+
+{{#if (includes examples "ai")}}
+import type { FastifyRequest, FastifyReply } from "fastify";
+import { streamText, type Message } from "ai";
+import { google } from "@ai-sdk/google";
+{{/if}}
+
+{{#if auth}}
+import { auth } from "./lib/auth";
+{{/if}}
+
+const baseCorsConfig = {
+  origin: process.env.CORS_ORIGIN || "",
+  methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+  allowedHeaders: [
+    "Content-Type",
+    "Authorization",
+    "X-Requested-With"
+  ],
+  credentials: true,
+  maxAge: 86400,
+};
+
+{{#if (eq api "orpc")}}
+const handler = new RPCHandler(appRouter, {
+  plugins: [
+    new CORSPlugin({
+      origin: process.env.CORS_ORIGIN,
+      credentials: true,
+      allowHeaders: ["Content-Type", "Authorization"],
+    }),
+  ],
+});
+
+const fastify = Fastify({
+  logger: true,
+  serverFactory: (fastifyHandler) => {
+    const server = createServer(async (req, res) => {
+      const { matched } = await handler.handle(req, res, {
+        context: await createContext(req.headers),
+        prefix: "/rpc",
+      });
+
+      if (matched) {
+        return;
+      }
+
+      fastifyHandler(req, res);
+    });
+
+    return server;
+  },
+});
+{{else}}
+const fastify = Fastify({
+  logger: true,
+});
+{{/if}}
+
+fastify.register(fastifyCors, baseCorsConfig);
+
+{{#if auth}}
+fastify.route({
+  method: ["GET", "POST"],
+  url: "/api/auth/*",
+  async handler(request, reply) {
+    try {
+      const url = new URL(request.url, `http://${request.headers.host}`);
+      const headers = new Headers();
+      Object.entries(request.headers).forEach(([key, value]) => {
+        if (value) headers.append(key, value.toString());
+      });
+      const req = new Request(url.toString(), {
+        method: request.method,
+        headers,
+        body: request.body ? JSON.stringify(request.body) : undefined,
+      });
+      const response = await auth.handler(req);
+      reply.status(response.status);
+      response.headers.forEach((value, key) => reply.header(key, value));
+      reply.send(response.body ? await response.text() : null);
+    } catch (error) {
+      fastify.log.error("Authentication Error:", error);
+      reply.status(500).send({
+        error: "Internal authentication error",
+        code: "AUTH_FAILURE"
+      });
+    }
+  }
+});
+{{/if}}
+
+{{#if (eq api "trpc")}}
+fastify.register(fastifyTRPCPlugin, {
+  prefix: "/trpc",
+  trpcOptions: {
+    router: appRouter,
+    createContext,
+    onError({ path, error }) {
+      console.error(`Error in tRPC handler on path '${path}':`, error);
+    },
+  } satisfies FastifyTRPCPluginOptions<AppRouter>["trpcOptions"],
+});
+{{/if}}
+
+{{#if (includes examples "ai")}}
+interface AiRequestBody {
+  id?: string;
+  messages: Message[];
+}
+
+fastify.post('/ai', async function (request, reply) {
+  const { messages } = request.body as AiRequestBody;
+  const result = streamText({
+    model: google('gemini-1.5-flash'),
+    messages,
+  });
+
+  reply.header('X-Vercel-AI-Data-Stream', 'v1');
+  reply.header('Content-Type', 'text/plain; charset=utf-8');
+
+  return reply.send(result.toDataStream());
+});
+{{/if}}
+
+fastify.get('/', async () => {
+  return 'OK'
+})
+
+fastify.listen({ port: 3000 }, (err) => {
+  if (err) {
+    fastify.log.error(err);
+    process.exit(1);
+  }
+  console.log("Server running on port 3000");
+});

package/templates/backend/server/hono/src/index.ts.hbs

@@ -0,0 +1,133 @@
+{{#if (or (eq runtime "bun") (eq runtime "node"))}}
+import "dotenv/config";
+{{/if}}
+{{#if (eq runtime "workers")}}
+import { env } from "cloudflare:workers";
+{{/if}}
+{{#if (eq api "orpc")}}
+import { RPCHandler } from "@orpc/server/fetch";
+import { createContext } from "./lib/context";
+import { appRouter } from "./routers/index";
+{{/if}}
+{{#if (eq api "trpc")}}
+import { trpcServer } from "@hono/trpc-server";
+import { createContext } from "./lib/context";
+import { appRouter } from "./routers/index";
+{{/if}}
+{{#if auth}}
+import { auth } from "./lib/auth";
+{{/if}}
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+{{#if (and (includes examples "ai") (or (eq runtime "bun") (eq runtime "node")))}}
+import { streamText } from "ai";
+import { google } from "@ai-sdk/google";
+import { stream } from "hono/streaming";
+{{/if}}
+{{#if (and (includes examples "ai") (eq runtime "workers"))}}
+import { streamText } from "ai";
+import { stream } from "hono/streaming";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+{{/if}}
+
+const app = new Hono();
+
+app.use(logger());
+app.use("/*", cors({
+  {{#if (or (eq runtime "bun") (eq runtime "node"))}}
+  origin: process.env.CORS_ORIGIN || "",
+  {{/if}}
+  {{#if (eq runtime "workers")}}
+  origin: env.CORS_ORIGIN || "",
+  {{/if}}
+  allowMethods: ["GET", "POST", "OPTIONS"],
+  {{#if auth}}
+  allowHeaders: ["Content-Type", "Authorization"],
+  credentials: true,
+  {{/if}}
+}));
+
+{{#if auth}}
+app.on(["POST", "GET"], "/api/auth/**", (c) => auth.handler(c.req.raw));
+{{/if}}
+
+{{#if (eq api "orpc")}}
+const handler = new RPCHandler(appRouter);
+app.use("/rpc/*", async (c, next) => {
+  const context = await createContext({ context: c });
+  const { matched, response } = await handler.handle(c.req.raw, {
+    prefix: "/rpc",
+    context: context,
+  });
+
+  if (matched) {
+    return c.newResponse(response.body, response);
+  }
+  await next();
+});
+{{/if}}
+
+{{#if (eq api "trpc")}}
+app.use("/trpc/*", trpcServer({
+  router: appRouter,
+  createContext: (_opts, context) => {
+    return createContext({ context });
+  },
+}));
+{{/if}}
+
+{{#if (and (includes examples "ai") (or (eq runtime "bun") (eq runtime "node")))}}
+app.post("/ai", async (c) => {
+  const body = await c.req.json();
+  const messages = body.messages || [];
+  const result = streamText({
+    model: google("gemini-1.5-flash"),
+    messages,
+  });
+
+  c.header("X-Vercel-AI-Data-Stream", "v1");
+  c.header("Content-Type", "text/plain; charset=utf-8");
+  return stream(c, (stream) => stream.pipe(result.toDataStream()));
+});
+{{/if}}
+
+{{#if (and (includes examples "ai") (eq runtime "workers"))}}
+app.post("/ai", async (c) => {
+  const body = await c.req.json();
+  const messages = body.messages || [];
+  const google = createGoogleGenerativeAI({
+    apiKey: env.GOOGLE_GENERATIVE_AI_API_KEY,
+  });
+  const result = streamText({
+    model: google("gemini-1.5-flash"),
+    messages,
+  });
+
+  c.header("X-Vercel-AI-Data-Stream", "v1");
+  c.header("Content-Type", "text/plain; charset=utf-8");
+  return stream(c, (stream) => stream.pipe(result.toDataStream()));
+});
+{{/if}}
+
+app.get("/", (c) => {
+  return c.text("OK");
+});
+
+{{#if (eq runtime "node")}}
+import { serve } from "@hono/node-server";
+
+serve({
+  fetch: app.fetch,
+  port: 3000,
+}, (info) => {
+  console.log(`Server is running on http://localhost:${info.port}`);
+});
+{{else}}
+  {{#if (eq runtime "bun")}}
+export default app;
+  {{/if}}
+  {{#if (eq runtime "workers")}}
+export default app;
+  {{/if}}
+{{/if}}

package/templates/backend/server/next/next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/templates/backend/server/next/next.config.ts

@@ -0,0 +1,7 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  /* config options here */
+};
+
+export default nextConfig;

package/templates/backend/server/next/package.json.hbs

@@ -0,0 +1,24 @@
+{
+  "name": "server",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev --turbopack",
+    "build": "next build",
+    "start": "next start"
+  },
+  "dependencies": {
+    "next": "15.3.0",
+    "dotenv": "^16.5.0"
+  },
+{{#if (eq dbSetup 'supabase')}}
+  "trustedDependencies": [
+    "supabase"
+   ],
+{{/if}}
+  "devDependencies": {
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "typescript": "^5"
+  }
+}

package/templates/backend/server/next/src/app/route.ts

@@ -0,0 +1,5 @@
+import { NextResponse } from "next/server";
+
+export async function GET() {
+  return NextResponse.json({ message: "OK" });
+}