@thinhnguyencth1204/nextcli 0.1.0

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@thinhnguyencth1204/nextcli",
+  "version": "0.1.0",
+  "description": "CLI scaffolder for outsourced Next.js projects",
+  "type": "module",
+  "bin": {
+    "nextcli": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "templates",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "smoke": "node dist/cli.js --help",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "cli",
+    "nextjs",
+    "scaffold",
+    "template"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.29",
+    "tsup": "^8.1.0",
+    "typescript": "^5.5.4"
+  }
+}

package/templates/features/chat/src/app/api/v1/chat/route.ts

@@ -0,0 +1,40 @@
+import { fail, ok } from "@/lib/api-response";
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const conversationId = searchParams.get("conversationId");
+  if (!conversationId) {
+    return fail("VALIDATION_ERROR", "conversationId is required.", { status: 400 });
+  }
+
+  return ok({
+    conversationId,
+    items: [],
+  });
+}
+
+export async function POST(request: Request) {
+  const payload = await request.json().catch(() => null);
+  const message = typeof payload?.message === "string" ? payload.message.trim() : "";
+  const conversationId =
+    typeof payload?.conversationId === "string" ? payload.conversationId.trim() : "";
+  const senderId = typeof payload?.senderId === "string" ? payload.senderId.trim() : "";
+
+  if (!conversationId || !senderId || !message) {
+    return fail(
+      "VALIDATION_ERROR",
+      "conversationId, senderId, and message are required.",
+      { status: 400 },
+    );
+  }
+
+  return ok({
+    sent: true,
+    message: {
+      conversationId,
+      senderId,
+      content: message,
+      kind: "TEXT",
+    },
+  });
+}

package/templates/features/chat/src/features/chat/api/use-chat-history.ts

@@ -0,0 +1,18 @@
+"use client";
+
+import { useQuery } from "@tanstack/react-query";
+import { api } from "@/lib/axios-instance";
+import type { ApiSuccess } from "@/types";
+
+export function useChatHistory(conversationId: string) {
+  return useQuery({
+    queryKey: ["chat", "history", conversationId],
+    enabled: Boolean(conversationId),
+    queryFn: async () => {
+      const { data } = await api.get("/api/v1/chat", {
+        params: { conversationId },
+      });
+      return (data as ApiSuccess<{ items: unknown[] }>).data.items;
+    },
+  });
+}

package/templates/features/chat/src/features/chat/api/use-realtime-sync.ts

@@ -0,0 +1,15 @@
+"use client";
+
+import { useEffect } from "react";
+
+export function useRealtimeSync(enabled: boolean) {
+  useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+
+    // Replace with your WebSocket/SSE implementation.
+    const interval = setInterval(() => {}, 5000);
+    return () => clearInterval(interval);
+  }, [enabled]);
+}

package/templates/features/chat/src/features/chat/api/use-send-message.ts

@@ -0,0 +1,35 @@
+"use client";
+
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { api } from "@/lib/axios-instance";
+import type { ApiSuccess } from "@/types";
+
+type SendMessageInput = {
+  conversationId: string;
+  senderId: string;
+  message: string;
+};
+
+export function useSendMessage() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (payload: SendMessageInput) => {
+      const { data } = await api.post("/api/v1/chat", payload);
+      return (data as ApiSuccess<{
+        sent: boolean;
+        message: {
+          conversationId: string;
+          senderId: string;
+          content: string;
+          kind: string;
+        };
+      }>).data;
+    },
+    onSuccess: async (_data, variables) => {
+      await queryClient.invalidateQueries({
+        queryKey: ["chat", "history", variables.conversationId],
+      });
+    },
+  });
+}

package/templates/features/chat/src/features/chat/components/ChatWidget.tsx

@@ -0,0 +1,40 @@
+"use client";
+
+import { useState } from "react";
+import { useChatHistory } from "@/features/chat/api/use-chat-history";
+import { useSendMessage } from "@/features/chat/api/use-send-message";
+
+export function ChatWidget() {
+  const defaultConversationId = "default-conversation";
+  const defaultSenderId = "demo-user";
+  const [message, setMessage] = useState("");
+  const history = useChatHistory(defaultConversationId);
+  const sendMessage = useSendMessage();
+
+  return (
+    <aside style={{ position: "fixed", right: 16, bottom: 16, width: 320, border: "1px solid #ccc", padding: 12 }}>
+      <h3>Chat</h3>
+      <div style={{ minHeight: 120, maxHeight: 180, overflowY: "auto" }}>
+        <pre>{JSON.stringify(history.data ?? [], null, 2)}</pre>
+      </div>
+      <form
+        onSubmit={(event) => {
+          event.preventDefault();
+          sendMessage.mutate({
+            conversationId: defaultConversationId,
+            senderId: defaultSenderId,
+            message,
+          });
+          setMessage("");
+        }}
+      >
+        <input
+          value={message}
+          onChange={(event) => setMessage(event.target.value)}
+          placeholder="Type message..."
+          style={{ width: "100%" }}
+        />
+      </form>
+    </aside>
+  );
+}

package/templates/features/chat/src/features/chat/services.ts

@@ -0,0 +1,27 @@
+export type ChatHistoryItem = {
+  id: string;
+  conversationId: string;
+  senderId: string;
+  content: string;
+  kind: "TEXT" | "SYSTEM";
+  createdAt: string;
+};
+
+export async function getChatHistory(conversationId: string): Promise<ChatHistoryItem[]> {
+  void conversationId;
+  return [];
+}
+
+export async function sendMessage(input: {
+  conversationId: string;
+  senderId: string;
+  message: string;
+}) {
+  return {
+    id: crypto.randomUUID(),
+    conversationId: input.conversationId,
+    senderId: input.senderId,
+    content: input.message,
+    kind: "TEXT" as const,
+  };
+}

package/templates/features/seo/public/robots.txt

@@ -0,0 +1,3 @@
+User-agent: *
+Allow: /
+Sitemap: http://localhost:3000/sitemap.xml

package/templates/features/seo/public/sitemap.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>http://localhost:3000</loc>
+  </url>
+</urlset>

package/templates/features/seo/src/app/robots.ts

@@ -0,0 +1,13 @@
+import type { MetadataRoute } from "next";
+
+export default function robots(): MetadataRoute.Robots {
+  const url = process.env.NEXT_PUBLIC_APP_URL ?? "http://localhost:3000";
+
+  return {
+    rules: {
+      userAgent: "*",
+      allow: "/",
+    },
+    sitemap: `${url}/sitemap.xml`,
+  };
+}

package/templates/features/seo/src/app/sitemap.ts

@@ -0,0 +1,21 @@
+import type { MetadataRoute } from "next";
+
+export default function sitemap(): MetadataRoute.Sitemap {
+  const url = process.env.NEXT_PUBLIC_APP_URL ?? "http://localhost:3000";
+  const now = new Date();
+
+  return [
+    {
+      url,
+      lastModified: now,
+      changeFrequency: "daily",
+      priority: 1,
+    },
+    {
+      url: `${url}/example`,
+      lastModified: now,
+      changeFrequency: "daily",
+      priority: 0.8,
+    },
+  ];
+}

package/templates/features/seo/src/components/seo/json-ld.tsx

@@ -0,0 +1,14 @@
+type JsonLdProps = {
+  data: Record<string, unknown>;
+};
+
+export function JsonLd({ data }: JsonLdProps) {
+  return (
+    <script
+      type="application/ld+json"
+      dangerouslySetInnerHTML={{
+        __html: JSON.stringify(data),
+      }}
+    />
+  );
+}

package/templates/features/supabase/src/lib/supabase/client.ts

@@ -0,0 +1,9 @@
+import { createClient } from "@supabase/supabase-js";
+
+const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
+const anonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+
+export const supabase =
+  url && anonKey
+    ? createClient(url, anonKey)
+    : null;

package/templates/features/supabase/src/lib/supabase/storage-config.ts

@@ -0,0 +1,69 @@
+export const DEFAULT_STORAGE_BUCKET =
+  process.env.NEXT_PUBLIC_SUPABASE_STORAGE_BUCKET?.trim() || "public";
+
+export const STORAGE_RESOURCE_CATEGORIES = [
+  "images",
+  "documents",
+  "avatars",
+  "misc",
+] as const;
+
+export type StorageResourceCategory =
+  (typeof STORAGE_RESOURCE_CATEGORIES)[number];
+
+const CATEGORY_DEFAULTS: Record<
+  StorageResourceCategory,
+  { maxBytes: number; allowedMimePrefixes: string[] }
+> = {
+  images: { maxBytes: 5 * 1024 * 1024, allowedMimePrefixes: ["image/"] },
+  documents: {
+    maxBytes: 10 * 1024 * 1024,
+    allowedMimePrefixes: [
+      "application/pdf",
+      "application/msword",
+      "application/vnd.",
+      "text/",
+    ],
+  },
+  avatars: { maxBytes: 2 * 1024 * 1024, allowedMimePrefixes: ["image/"] },
+  misc: { maxBytes: 10 * 1024 * 1024, allowedMimePrefixes: [] },
+};
+
+export function getStorageCategoryDefaults(category: StorageResourceCategory) {
+  return CATEGORY_DEFAULTS[category];
+}
+
+export function sanitizeStorageFileName(fileName: string): string {
+  const base = fileName.split(/[/\\]/).pop() ?? "file";
+  const sanitized = base
+    .normalize("NFKD")
+    .replace(/[^\w.\-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 120);
+
+  return sanitized || "file";
+}
+
+function sanitizeStorageScope(scope: string): string {
+  const sanitized = scope
+    .trim()
+    .replace(/[^a-zA-Z0-9_-]/g, "-")
+    .replace(/-+/g, "-")
+    .slice(0, 64);
+
+  return sanitized || "shared";
+}
+
+export function buildStorageObjectPath(input: {
+  scope: string;
+  category: StorageResourceCategory;
+  fileName: string;
+  uniqueId?: string;
+}): string {
+  const scope = sanitizeStorageScope(input.scope);
+  const uniqueId = input.uniqueId ?? crypto.randomUUID();
+  const safeName = sanitizeStorageFileName(input.fileName);
+
+  return `${scope}/${input.category}/${uniqueId}-${safeName}`;
+}

package/templates/features/supabase/src/lib/supabase/storage.ts

@@ -0,0 +1,167 @@
+import { supabase } from "@/lib/supabase/client";
+import {
+  DEFAULT_STORAGE_BUCKET,
+  buildStorageObjectPath,
+  getStorageCategoryDefaults,
+  type StorageResourceCategory,
+} from "@/lib/supabase/storage-config";
+
+export type UploadResourceInput = {
+  file: File | Blob;
+  fileName: string;
+  /** Tenant/user/feature namespace, e.g. user id or `shared`. */
+  scope: string;
+  category?: StorageResourceCategory;
+  bucket?: string;
+  upsert?: boolean;
+  cacheControl?: string;
+  contentType?: string;
+};
+
+export type UploadResourceResult = {
+  bucket: string;
+  path: string;
+  publicUrl: string;
+};
+
+export class StorageHelperError extends Error {
+  constructor(
+    message: string,
+    readonly code:
+      | "NOT_CONFIGURED"
+      | "VALIDATION"
+      | "UPLOAD_FAILED"
+      | "REMOVE_FAILED",
+    readonly cause?: unknown,
+  ) {
+    super(message);
+    this.name = "StorageHelperError";
+  }
+}
+
+function getClient() {
+  if (!supabase) {
+    throw new StorageHelperError(
+      "Supabase is not configured. Set NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_ANON_KEY.",
+      "NOT_CONFIGURED",
+    );
+  }
+
+  return supabase;
+}
+
+function resolveContentType(
+  file: File | Blob,
+  override?: string,
+): string | undefined {
+  if (override) {
+    return override;
+  }
+
+  if (file instanceof File && file.type) {
+    return file.type;
+  }
+
+  return undefined;
+}
+
+function assertCategoryRules(
+  category: StorageResourceCategory,
+  file: File | Blob,
+  contentType?: string,
+): void {
+  const { maxBytes, allowedMimePrefixes } =
+    getStorageCategoryDefaults(category);
+
+  if (file.size > maxBytes) {
+    throw new StorageHelperError(
+      `File exceeds ${category} limit of ${maxBytes} bytes.`,
+      "VALIDATION",
+    );
+  }
+
+  if (allowedMimePrefixes.length === 0) {
+    return;
+  }
+
+  const mime = contentType ?? (file instanceof File ? file.type : "");
+
+  if (
+    !mime ||
+    !allowedMimePrefixes.some((prefix) => mime.startsWith(prefix))
+  ) {
+    throw new StorageHelperError(
+      `File type "${mime || "unknown"}" is not allowed for category "${category}".`,
+      "VALIDATION",
+    );
+  }
+}
+
+export function getResourcePublicUrl(
+  path: string,
+  bucket: string = DEFAULT_STORAGE_BUCKET,
+): string {
+  const client = getClient();
+  const { data } = client.storage.from(bucket).getPublicUrl(path);
+
+  return data.publicUrl;
+}
+
+export async function uploadResource(
+  input: UploadResourceInput,
+): Promise<UploadResourceResult> {
+  const client = getClient();
+  const bucket = input.bucket ?? DEFAULT_STORAGE_BUCKET;
+  const category = input.category ?? "images";
+  const contentType = resolveContentType(input.file, input.contentType);
+
+  assertCategoryRules(category, input.file, contentType);
+
+  const path = buildStorageObjectPath({
+    scope: input.scope,
+    category,
+    fileName: input.fileName,
+  });
+
+  const { error } = await client.storage.from(bucket).upload(path, input.file, {
+    contentType,
+    cacheControl: input.cacheControl ?? "3600",
+    upsert: input.upsert ?? false,
+  });
+
+  if (error) {
+    throw new StorageHelperError(
+      error.message || "Upload failed.",
+      "UPLOAD_FAILED",
+      error,
+    );
+  }
+
+  return {
+    bucket,
+    path,
+    publicUrl: getResourcePublicUrl(path, bucket),
+  };
+}
+
+export async function uploadImage(
+  input: Omit<UploadResourceInput, "category">,
+): Promise<UploadResourceResult> {
+  return uploadResource({ ...input, category: "images" });
+}
+
+export async function removeResource(
+  path: string,
+  bucket: string = DEFAULT_STORAGE_BUCKET,
+): Promise<void> {
+  const client = getClient();
+  const { error } = await client.storage.from(bucket).remove([path]);
+
+  if (error) {
+    throw new StorageHelperError(
+      error.message || "Remove failed.",
+      "REMOVE_FAILED",
+      error,
+    );
+  }
+}

package/templates/features/supabase-realtime/src/features/supabase-realtime/client.ts

@@ -0,0 +1,9 @@
+import { createClient } from "@supabase/supabase-js";
+
+const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
+const anonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+
+export const supabaseRealtimeClient =
+  url && anonKey
+    ? createClient(url, anonKey)
+    : null;

package/templates/features/supabase-realtime/src/features/supabase-realtime/use-supabase-channel.ts

@@ -0,0 +1,19 @@
+"use client";
+
+import { useEffect } from "react";
+import { supabaseRealtimeClient } from "@/features/supabase-realtime/client";
+
+export function useSupabaseChannel(channelName: string) {
+  useEffect(() => {
+    if (!supabaseRealtimeClient || !channelName) {
+      return;
+    }
+
+    const channel = supabaseRealtimeClient.channel(channelName);
+    channel.subscribe();
+
+    return () => {
+      channel.unsubscribe();
+    };
+  }, [channelName]);
+}

package/templates/next-base/.env

@@ -0,0 +1,11 @@
+DATABASE_URL="postgresql://postgres:postgres@localhost:5432/__PROJECT_NAME__"
+BETTER_AUTH_SECRET="__BETTER_AUTH_SECRET__"
+BETTER_AUTH_URL="http://localhost:3000"
+
+NEXT_PUBLIC_APP_URL="http://localhost:3000"
+NEXT_PUBLIC_ENABLE_CHAT=__ENABLE_CHAT__
+NEXT_PUBLIC_DEFAULT_LOCALE="en"
+GOOGLE_CLIENT_ID=""
+GOOGLE_CLIENT_SECRET=""
+FACEBOOK_CLIENT_ID=""
+FACEBOOK_CLIENT_SECRET=""

package/templates/next-base/.env.development

@@ -0,0 +1,11 @@
+DATABASE_URL="postgresql://postgres:postgres@localhost:5432/__PROJECT_NAME___dev"
+BETTER_AUTH_SECRET="__BETTER_AUTH_SECRET__"
+BETTER_AUTH_URL="http://localhost:3000"
+
+NEXT_PUBLIC_APP_URL="http://localhost:3000"
+NEXT_PUBLIC_ENABLE_CHAT=__ENABLE_CHAT__
+NEXT_PUBLIC_DEFAULT_LOCALE="en"
+GOOGLE_CLIENT_ID=""
+GOOGLE_CLIENT_SECRET=""
+FACEBOOK_CLIENT_ID=""
+FACEBOOK_CLIENT_SECRET=""

package/templates/next-base/.env.example

@@ -0,0 +1,11 @@
+DATABASE_URL="postgresql://postgres:postgres@localhost:5432/__PROJECT_NAME__"
+BETTER_AUTH_SECRET="your-32-plus-char-random-secret"
+BETTER_AUTH_URL="http://localhost:3000"
+
+NEXT_PUBLIC_APP_URL="http://localhost:3000"
+NEXT_PUBLIC_ENABLE_CHAT=__ENABLE_CHAT__
+NEXT_PUBLIC_DEFAULT_LOCALE="en"
+GOOGLE_CLIENT_ID=""
+GOOGLE_CLIENT_SECRET=""
+FACEBOOK_CLIENT_ID=""
+FACEBOOK_CLIENT_SECRET=""

package/templates/next-base/eslint.config.mjs

@@ -0,0 +1,20 @@
+import js from "@eslint/js";
+import nextPlugin from "eslint-config-next";
+
+const config = [
+  js.configs.recommended,
+  ...nextPlugin,
+  {
+    ignores: [".next/**", "node_modules/**", "dist/**"],
+  },
+  {
+    files: ["**/*.{ts,tsx}"],
+    rules: {
+      "no-undef": "off",
+      "no-unused-vars": "off",
+      "react-hooks/incompatible-library": "off",
+    },
+  },
+];
+
+export default config;

package/templates/next-base/middleware.ts

@@ -0,0 +1,10 @@
+import createMiddleware from "next-intl/middleware";
+
+export default createMiddleware({
+  locales: ["en", "vi"],
+  defaultLocale: "en",
+});
+
+export const config = {
+  matcher: ["/((?!api|_next|.*\\..*).*)"],
+};

package/templates/next-base/next-env.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// This file is auto-generated by Next.js and should not be edited manually.

package/templates/next-base/next.config.ts

@@ -0,0 +1,7 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  reactStrictMode: true,
+};
+
+export default nextConfig;