@ahmadubaidillah/cli 1.1.2 → 1.1.4

package/dist/plugins/auth/files/src/modules/auth/routes/auth.routes.ts

@@ -0,0 +1,40 @@
+import { Hono } from 'hono';
+import { signupSchema, loginSchema, organizationSchema } from '../auth.schema';
+
+export const authRoutes = new Hono();
+
+authRoutes.post('/signup', async (c) => {
+  const body = await c.req.json();
+  const result = signupSchema.safeParse(body);
+  if (!result.success) return c.json({ error: result.error.format() }, 400);
+  return c.json({ message: 'User signed up successfully' });
+});
+
+authRoutes.post('/login', async (c) => {
+  const body = await c.req.json();
+  const result = loginSchema.safeParse(body);
+  if (!result.success) return c.json({ error: result.error.format() }, 400);
+  return c.json({ message: 'User logged in successfully' });
+});
+
+authRoutes.get('/me', (c) => {
+  return c.json({ user: { id: '1', email: 'user@example.com' } });
+});
+
+/**
+ * Organization Management
+ */
+authRoutes.post('/organizations', async (c) => {
+  const body = await c.req.json();
+  const result = organizationSchema.safeParse(body);
+  if (!result.success) return c.json({ error: result.error.format() }, 400);
+  return c.json({ message: 'Organization created successfully', id: 'org_123' });
+});
+
+authRoutes.get('/organizations', (c) => {
+  return c.json({ 
+    organizations: [
+      { id: 'org_123', name: 'DevForge Team', slug: 'devforge' }
+    ] 
+  });
+});

package/dist/plugins/auth/files/src/modules/auth/services/auth.service.ts

@@ -0,0 +1,113 @@
+import { betterAuth } from "better-auth";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { organization } from "better-auth/plugins";
+// In a scaffolded project, this usually resolves to @devforge/core or relative path
+// For the purpose of the SDK, we'll assume a relative path for now
+import { eventBus } from "../../../../../../../core/src/hooks/event-bus";
+
+/**
+ * AuthService
+ * 
+ * This service provides a robust wrapper around Better Auth.
+ * It is designed to work with Drizzle ORM.
+ */
+export class AuthService {
+  public auth: any;
+
+  constructor(db: any, provider: "pg" | "sqlite" | "mysql" = "pg", schema?: any) {
+    this.auth = betterAuth({
+      database: drizzleAdapter(db, {
+        provider,
+        schema,
+      }),
+      secret: process.env.BETTER_AUTH_SECRET || "development_secret_only_for_scaffolding",
+      baseURL: process.env.BETTER_AUTH_URL || "http://localhost:3000",
+      emailAndPassword: {
+        enabled: true
+      },
+      plugins: [
+        organization({
+          allowUserToCreateOrganization: true,
+          creatorRole: "owner",
+        })
+      ]
+    });
+  }
+
+  /**
+   * Authenticate a user with email and password.
+   * Returns user data and headers to be sent to the client.
+   */
+  async login(credentials: { email: string; password: string }) {
+    try {
+      const response = await this.auth.api.signInEmail({
+        body: {
+          email: credentials.email,
+          password: credentials.password,
+        }
+      });
+      // Better Auth returns a response object that can include headers for setting cookies
+      return { 
+        success: true, 
+        user: response.user, 
+        session: response.session,
+        headers: response.headers 
+      };
+    } catch (error: any) {
+      throw new Error(error.message || 'Login failed');
+    }
+  }
+
+  /**
+   * Create a new user account.
+   */
+  async signup(data: any) {
+    try {
+      const response = await this.auth.api.signUpEmail({
+        body: {
+          email: data.email,
+          password: data.password,
+          name: data.name,
+        }
+      });
+      return { 
+        success: true, 
+        user: response.user, 
+        session: response.session,
+        headers: response.headers
+      };
+    } catch (error: any) {
+      throw new Error(error.message || 'Signup failed');
+    }
+  }
+
+  /**
+   * Create an organization.
+   */
+  async createOrganization(data: any, user: any) {
+    try {
+      const org = await this.auth.api.createOrganization({
+        body: data,
+        headers: new Headers({ "authorization": `Bearer ${user.id}` }) // Mocking auth for example
+      });
+      
+      eventBus.dispatch('org.created', { org, creatorId: user.id });
+      
+      return org;
+    } catch (error: any) {
+      throw new Error(error.message || 'Organization creation failed');
+    }
+  }
+
+  /**
+   * Retrieve the current session from the request headers.
+   */
+  async getSession(request: Request | { headers: Headers }) {
+    try {
+      return await this.auth.api.getSession({ headers: request.headers });
+    } catch (error) {
+      return null;
+    }
+  }
+}
+

package/dist/plugins/auth/plugin.config.json

@@ -0,0 +1,9 @@
+{
+  "name": "auth",
+  "description": "Authentication module using Better Auth",
+  "compatibleTemplates": ["saas", "cms", "marketplace", "booking", "finance", "crm"],
+  "packageDependencies": {
+    "better-auth": "latest",
+    "@better-auth/drizzle-adapter": "latest"
+  }
+}

package/dist/plugins/cms/files/src/modules/cms/cms.schema.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+
+export const postSchema = z.object({
+  title: z.string().min(1),
+  content: z.string().min(1),
+  slug: z.string().min(1),
+  categoryId: z.string().optional(),
+  tagIds: z.array(z.string()).optional(),
+  status: z.enum(['draft', 'published']).default('draft'),
+});
+
+export const categorySchema = z.object({
+  name: z.string().min(1),
+  slug: z.string().min(1),
+  description: z.string().optional(),
+});
+
+export const tagSchema = z.object({
+  name: z.string().min(1),
+});
+
+export type PostInput = z.infer<typeof postSchema>;
+export type CategoryInput = z.infer<typeof categorySchema>;
+export type TagInput = z.infer<typeof tagSchema>;

package/dist/plugins/cms/files/src/modules/cms/db/schema.ts

@@ -0,0 +1,88 @@
+import { pgTable, text, timestamp, uuid, index, primaryKey, jsonb } from "drizzle-orm/pg-core";
+
+/**
+ * Categories Table
+ * Allows organizing posts into primary buckets.
+ */
+export const categories = pgTable("category", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  name: text("name").notNull(),
+  slug: text("slug").notNull(),
+  organizationId: text("organization_id").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => [
+  index("category_org_idx").on(table.organizationId),
+  index("category_slug_idx").on(table.slug),
+]);
+
+/**
+ * Tags Table
+ * Flexible labeling system for posts.
+ */
+export const tags = pgTable("tag", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  name: text("name").notNull(),
+  slug: text("slug").notNull(),
+  organizationId: text("organization_id").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => [
+  index("tag_org_idx").on(table.organizationId),
+  index("tag_slug_idx").on(table.slug),
+]);
+
+/**
+ * Posts Table
+ * Updated with category, featured image, and SEO metadata.
+ */
+export const posts = pgTable("post", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  title: text("title").notNull(),
+  slug: text("slug").notNull(),
+  content: jsonb("content"), // Support for rich text JSON
+  seo: jsonb("seo"), // Metadata: title, description, ogImage
+  status: text("status", { enum: ["draft", "published"] }).default("draft").notNull(),
+  authorId: text("author_id").notNull(),
+  organizationId: text("organization_id").notNull(),
+  categoryId: uuid("category_id").references(() => categories.id),
+  featuredImageId: text("featured_image_id"), // Refers to external storage plugin
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at")
+    .defaultNow()
+    .$onUpdate(() => new Date())
+    .notNull(),
+}, (table) => [
+  index("post_org_idx").on(table.organizationId),
+  index("post_slug_idx").on(table.slug),
+]);
+
+/**
+ * Post-Tags Junction Table
+ * Many-to-Many relationship between Posts and Tags.
+ */
+export const postTags = pgTable("post_tag", {
+  postId: uuid("post_id").notNull().references(() => posts.id, { onDelete: 'cascade' }),
+  tagId: uuid("tag_id").notNull().references(() => tags.id, { onDelete: 'cascade' }),
+}, (table) => [
+  primaryKey({ columns: [table.postId, table.tagId] })
+]);
+
+/**
+ * Pages Table
+ * Updated with SEO metadata.
+ */
+export const pages = pgTable("page", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  title: text("title").notNull(),
+  slug: text("slug").notNull(),
+  content: jsonb("content"),
+  seo: jsonb("seo"),
+  organizationId: text("organization_id").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at")
+    .defaultNow()
+    .$onUpdate(() => new Date())
+    .notNull(),
+}, (table) => [
+  index("page_org_idx").on(table.organizationId),
+  index("page_slug_idx").on(table.slug),
+]);

package/dist/plugins/cms/files/src/modules/cms/routes/cms.routes.ts

@@ -0,0 +1,67 @@
+import { Hono } from 'hono';
+import { CMSService } from '../services/cms.service';
+import { postSchema, categorySchema, tagSchema } from '../cms.schema';
+
+export const cmsRoutes = new Hono<{
+  Variables: {
+    organizationId: string;
+    db: any;
+  }
+}>();
+
+// --- Posts ---
+cmsRoutes.get('/posts', async (c) => {
+  const cmsService = new CMSService(c.get('db'));
+  const categorySlug = c.req.query('category');
+  const posts = await cmsService.getPosts(c.get('organizationId'), { categorySlug });
+  return c.json({ posts });
+});
+
+cmsRoutes.post('/posts', async (c) => {
+  const cmsService = new CMSService(c.get('db'));
+  const body = await c.req.json();
+  const result = postSchema.safeParse(body);
+  if (!result.success) return c.json({ error: result.error.format() }, 400);
+  const post = await cmsService.createPost(body, c.get('organizationId'));
+  return c.json({ post });
+});
+
+// --- Categories ---
+cmsRoutes.get('/categories', async (c) => {
+  const cmsService = new CMSService(c.get('db'));
+  const categories = await cmsService.getCategories(c.get('organizationId'));
+  return c.json({ categories });
+});
+
+cmsRoutes.post('/categories', async (c) => {
+  const cmsService = new CMSService(c.get('db'));
+  const body = await c.req.json();
+  const result = categorySchema.safeParse(body);
+  if (!result.success) return c.json({ error: result.error.format() }, 400);
+  const category = await cmsService.createCategory(body, c.get('organizationId'));
+  return c.json({ category });
+});
+
+// --- Tags ---
+cmsRoutes.get('/tags', async (c) => {
+  const cmsService = new CMSService(c.get('db'));
+  const tags = await cmsService.getTags(c.get('organizationId'));
+  return c.json({ tags });
+});
+
+cmsRoutes.post('/tags', async (c) => {
+  const cmsService = new CMSService(c.get('db'));
+  const body = await c.req.json();
+  const result = tagSchema.safeParse(body);
+  if (!result.success) return c.json({ error: result.error.format() }, 400);
+  const tag = await cmsService.createTag(body, c.get('organizationId'));
+  return c.json({ tag });
+});
+
+// --- Pages ---
+cmsRoutes.get('/pages/:slug', async (c) => {
+  const cmsService = new CMSService(c.get('db'));
+  const page = await cmsService.getPageBySlug(c.req.param('slug'), c.get('organizationId'));
+  if (!page) return c.json({ message: 'Page not found' }, 404);
+  return c.json({ page });
+});

package/dist/plugins/cms/files/src/modules/cms/services/cms.service.ts

@@ -0,0 +1,99 @@
+import { eq, and, inArray } from 'drizzle-orm';
+import { posts, pages, categories, tags, postTags } from '../db/schema';
+import { eventBus } from '../../../../../../../core/src/hooks/event-bus';
+
+export class CMSService {
+  private db: any;
+
+  constructor(db: any) {
+    this.db = db;
+  }
+
+  // --- Posts ---
+  async getPosts(organizationId: string, options: { categorySlug?: string } = {}) {
+    try {
+      let query = this.db.select().from(posts).where(eq(posts.organizationId, organizationId));
+      
+      if (options.categorySlug) {
+        const cat = await this.getCategoryBySlug(options.categorySlug, organizationId);
+        if (cat) {
+          query = this.db.select().from(posts).where(
+            and(eq(posts.organizationId, organizationId), eq(posts.categoryId, cat.id))
+          );
+        }
+      }
+      
+      return await query;
+    } catch (error: any) {
+      console.error(`[CMSService] Failed to fetch posts: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async createPost(data: any, organizationId: string) {
+    try {
+      const { tagIds, ...postData } = data;
+      const [post] = await this.db.insert(posts).values({
+        ...postData,
+        organizationId,
+      }).returning();
+
+      if (tagIds && tagIds.length > 0) {
+        await this.db.insert(postTags).values(
+          tagIds.map((tagId: string) => ({ postId: post.id, tagId }))
+        );
+      }
+      
+      eventBus.dispatch('cms.post.created', { post, organizationId });
+
+      return post;
+    } catch (error: any) {
+      console.error(`[CMSService] Post creation failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // --- Categories ---
+  async getCategories(organizationId: string) {
+    return await this.db.select().from(categories).where(eq(categories.organizationId, organizationId));
+  }
+
+  async createCategory(data: any, organizationId: string) {
+    try {
+      return await this.db.insert(categories).values({
+        ...data,
+        organizationId,
+      }).returning();
+    } catch (error: any) {
+      console.error(`[CMSService] Category creation failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async getCategoryBySlug(slug: string, organizationId: string) {
+    const [category] = await this.db.select()
+      .from(categories)
+      .where(and(eq(categories.slug, slug), eq(categories.organizationId, organizationId)));
+    return category;
+  }
+
+  // --- Tags ---
+  async getTags(organizationId: string) {
+    return await this.db.select().from(tags).where(eq(tags.organizationId, organizationId));
+  }
+
+  async createTag(data: any, organizationId: string) {
+    return await this.db.insert(tags).values({
+      ...data,
+      organizationId,
+    }).returning();
+  }
+
+  // --- Pages ---
+  async getPageBySlug(slug: string, organizationId: string) {
+    const [page] = await this.db.select()
+      .from(pages)
+      .where(and(eq(pages.slug, slug), eq(pages.organizationId, organizationId)));
+    return page;
+  }
+}

package/dist/plugins/cms/plugin.config.json

@@ -0,0 +1,9 @@
+{
+  "name": "cms",
+  "description": "Headless CMS module for managing posts and pages",
+  "compatibleTemplates": ["saas", "cms", "marketplace"],
+  "packageDependencies": {
+    "drizzle-orm": "latest"
+  },
+  "pluginDependencies": ["auth", "file_upload"]
+}

package/dist/plugins/deployment/files/Dockerfile

@@ -0,0 +1,33 @@
+# Stage 1: Build
+FROM oven/bun:latest AS builder
+
+WORKDIR /app
+
+COPY package.json ./
+COPY bun.lockb* ./
+
+RUN bun install --frozen-lockfile
+
+COPY . .
+
+# If there's a build step, run it
+RUN if [ -f "src/app.ts" ]; then bun build ./src/app.ts --outdir ./dist; fi
+
+# Stage 2: Production
+FROM oven/bun:distroless
+
+WORKDIR /app
+
+# Copy only the built assets and necessary files
+COPY --from=builder /app/package.json ./
+COPY --from=builder /app/src ./src
+COPY --from=builder /app/node_modules ./node_modules
+
+# Environment variables
+ENV NODE_ENV=production
+ENV PORT=3000
+
+EXPOSE 3000
+
+# Start the application
+CMD ["run", "src/app.ts"]

package/dist/plugins/deployment/files/docker-compose.yml

@@ -0,0 +1,27 @@
+version: '3.8'
+
+services:
+  "app-{{PROJECT_NAME}}":
+    container_name: "{{PROJECT_NAME}}-app"
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=development
+      - DATABASE_URL=postgres://user:pass@db:5432/devforge
+    depends_on:
+      - db
+
+  db:
+    image: postgres:15-alpine
+    environment:
+      - POSTGRES_USER=user
+      - POSTGRES_PASSWORD=pass
+      - POSTGRES_DB=devforge
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"
+
+volumes:
+  pgdata:

package/dist/plugins/deployment/files/vercel.json

@@ -0,0 +1,14 @@
+{
+  "version": 2,
+  "framework": "hono",
+  "name": "{{PROJECT_NAME}}",
+  "installCommand": "bun install",
+  "buildCommand": "bun run build",
+  "outputDirectory": "dist",
+  "rewrites": [
+    {
+      "source": "/(.*)",
+      "destination": "/api"
+    }
+  ]
+}

package/dist/plugins/deployment/plugin.config.json

@@ -0,0 +1,5 @@
+{
+  "name": "deployment",
+  "description": "Docker and Vercel deployment configurations for various stacks.",
+  "compatibleTemplates": ["saas", "cms", "marketplace", "ai_wrapper", "preact"]
+}

package/dist/plugins/email/files/src/modules/email/services/email.service.ts

@@ -0,0 +1,30 @@
+import { Resend } from 'resend';
+
+export interface EmailOptions {
+  to: string | string[];
+  subject: string;
+  html: string;
+  from?: string;
+}
+
+export class EmailService {
+  private resend: Resend;
+
+  constructor(apiKey: string) {
+    this.resend = new Resend(apiKey);
+  }
+
+  async sendEmail(options: EmailOptions) {
+    try {
+      return await this.resend.emails.send({
+        from: options.from || 'noreply@{{DOMAIN}}',
+        to: options.to,
+        subject: options.subject,
+        html: options.html,
+      });
+    } catch (error: any) {
+      console.error(`[EmailService] Failed to send email: ${error.message}`);
+      throw error;
+    }
+  }
+}

package/dist/plugins/email/plugin.config.json

@@ -0,0 +1,9 @@
+{
+  "name": "email",
+  "description": "Transactional email service with support for multiple providers.",
+  "compatibleTemplates": ["saas", "marketplace", "booking", "crm", "cms", "landing"],
+  "packageDependencies": {
+    "resend": "latest",
+    "zod": "^3.22.4"
+  }
+}

package/dist/plugins/file_upload/files/src/modules/storage/services/storage.service.ts

@@ -0,0 +1,39 @@
+import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+
+export class StorageService {
+  private client: S3Client;
+
+  constructor(config: { region: string; credentials: { accessKeyId: string; secretAccessKey: string } }) {
+    this.client = new S3Client(config);
+  }
+
+  async getUploadUrl(bucket: string, key: string, expiresIn: number = 3600) {
+    try {
+      const command = new PutObjectCommand({
+        Bucket: bucket,
+        Key: key,
+      });
+
+      return await getSignedUrl(this.client, command, { expiresIn });
+    } catch (error: any) {
+      console.error(`[StorageService] Failed to get upload URL: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async uploadFile(bucket: string, key: string, body: Buffer | Uint8Array | string) {
+    try {
+      const command = new PutObjectCommand({
+        Bucket: bucket,
+        Key: key,
+        Body: body,
+      });
+
+      return await this.client.send(command);
+    } catch (error: any) {
+      console.error(`[StorageService] File upload failed: ${error.message}`);
+      throw error;
+    }
+  }
+}

package/dist/plugins/file_upload/plugin.config.json

@@ -0,0 +1,10 @@
+{
+  "name": "file_upload",
+  "description": "S3-compatible file upload service.",
+  "compatibleTemplates": ["saas", "marketplace", "cms", "crm"],
+  "packageDependencies": {
+    "@aws-sdk/client-s3": "latest",
+    "@aws-sdk/s3-request-presigner": "latest",
+    "zod": "^3.22.4"
+  }
+}

package/dist/plugins/github-actions/files/.github/workflows/ci.yml

@@ -0,0 +1,34 @@
+name: DevForge Post-Scaffold CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [20.x]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Install Dependencies
+        run: bun install
+
+      - name: Run Typecheck
+        run: bun run typecheck
+
+      - name: Run Linter
+        run: bun lint
+
+      - name: Execute Tests
+        run: bun test --coverage

package/dist/plugins/github-actions/plugin.config.json

@@ -0,0 +1,14 @@
+{
+  "name": "github-actions",
+  "description": "DevForge github-actions CI Pipeline generator",
+  "compatibleTemplates": [
+    "saas",
+    "marketplace",
+    "crm",
+    "ai_wrapper",
+    "booking",
+    "finance"
+  ],
+  "packageDependencies": {},
+  "packageDevDependencies": {}
+}