create-atsdc-stack 1.0.0

package/app/src/db/validations.ts

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+
+/**
+ * Zod validation schemas for database models
+ * Provides runtime type safety and validation for user inputs
+ */
+
+// Slug validation helper
+const slugSchema = z
+    .string()
+    .min(1, 'Slug is required')
+    .max(255, 'Slug must be 255 characters or less')
+    .regex(
+        /^[a-z0-9]+(?:-[a-z0-9]+)*$/,
+        'Slug must be lowercase alphanumeric with hyphens only'
+    );
+
+/**
+ * Post validation schemas
+ */
+
+// Schema for creating a new post
+export const createPostSchema = z.object({
+    title: z
+        .string()
+        .min(1, 'Title is required')
+        .max(255, 'Title must be 255 characters or less')
+        .trim(),
+
+    slug: slugSchema,
+
+    content: z
+        .string()
+        .min(1, 'Content is required')
+        .max(50000, 'Content must be 50,000 characters or less'),
+
+    excerpt: z
+        .string()
+        .max(500, 'Excerpt must be 500 characters or less')
+        .optional()
+        .nullable(),
+
+    authorId: z.string().min(1, 'Author ID is required'),
+
+    authorName: z
+        .string()
+        .max(255, 'Author name must be 255 characters or less')
+        .optional()
+        .nullable(),
+
+    published: z.boolean().default(false),
+
+    featured: z.boolean().default(false),
+
+    metaTitle: z
+        .string()
+        .max(255, 'Meta title must be 255 characters or less')
+        .optional()
+        .nullable(),
+
+    metaDescription: z
+        .string()
+        .max(500, 'Meta description must be 500 characters or less')
+        .optional()
+        .nullable(),
+});
+
+// Schema for updating an existing post
+export const updatePostSchema = createPostSchema.partial().extend({
+    id: z.string().length(21, 'Invalid post ID'),
+});
+
+// Schema for publishing/unpublishing a post
+export const publishPostSchema = z.object({
+    id: z.string().length(21, 'Invalid post ID'),
+    published: z.boolean(),
+});
+
+// Schema for post query parameters
+export const postQuerySchema = z.object({
+    page: z.coerce.number().int().positive().default(1),
+    limit: z.coerce.number().int().positive().max(100).default(10),
+    published: z
+        .string()
+        .transform((val) => val === 'true')
+        .optional(),
+    featured: z
+        .string()
+        .transform((val) => val === 'true')
+        .optional(),
+    authorId: z.string().optional(),
+    search: z.string().optional(),
+});
+
+/**
+ * Comment validation schemas
+ */
+
+// Schema for creating a new comment
+export const createCommentSchema = z.object({
+    postId: z.string().length(21, 'Invalid post ID'),
+
+    content: z
+        .string()
+        .min(1, 'Comment content is required')
+        .max(2000, 'Comment must be 2,000 characters or less')
+        .trim(),
+
+    authorId: z.string().min(1, 'Author ID is required'),
+
+    authorName: z
+        .string()
+        .max(255, 'Author name must be 255 characters or less')
+        .optional()
+        .nullable(),
+});
+
+// Schema for updating a comment
+export const updateCommentSchema = z.object({
+    id: z.string().length(21, 'Invalid comment ID'),
+    content: z
+        .string()
+        .min(1, 'Comment content is required')
+        .max(2000, 'Comment must be 2,000 characters or less')
+        .trim(),
+});
+
+// Schema for moderating a comment
+export const moderateCommentSchema = z.object({
+    id: z.string().length(21, 'Invalid comment ID'),
+    approved: z.boolean().optional(),
+    flagged: z.boolean().optional(),
+});
+
+// Schema for comment query parameters
+export const commentQuerySchema = z.object({
+    postId: z.string().length(21, 'Invalid post ID').optional(),
+    page: z.coerce.number().int().positive().default(1),
+    limit: z.coerce.number().int().positive().max(100).default(20),
+    approved: z
+        .string()
+        .transform((val) => val === 'true')
+        .optional(),
+    authorId: z.string().optional(),
+});
+
+/**
+ * Type exports for use in application
+ */
+export type CreatePostInput = z.infer<typeof createPostSchema>;
+export type UpdatePostInput = z.infer<typeof updatePostSchema>;
+export type PublishPostInput = z.infer<typeof publishPostSchema>;
+export type PostQueryInput = z.infer<typeof postQuerySchema>;
+
+export type CreateCommentInput = z.infer<typeof createCommentSchema>;
+export type UpdateCommentInput = z.infer<typeof updateCommentSchema>;
+export type ModerateCommentInput = z.infer<typeof moderateCommentSchema>;
+export type CommentQueryInput = z.infer<typeof commentQuerySchema>;

package/app/src/env.d.ts

@@ -0,0 +1 @@
+/// <reference path="../.astro/types.d.ts" />

package/app/src/layouts/Layout.astro

@@ -0,0 +1,63 @@
+---
+/**
+ * Base Layout Component
+ * Demonstrates proper SCSS architecture:
+ * - No <style> tags in this file
+ * - All styles imported from external SCSS files
+ * - Global styles applied via import in the head
+ */
+
+import { siteConfig } from '@/lib/config';
+
+interface Props {
+    pageTitle?: string | string[];
+    description?: string;
+}
+
+const {
+    pageTitle,
+    description = siteConfig.stackDescription,
+} = Astro.props;
+
+const pageArray = Array.isArray(pageTitle) ? pageTitle : [pageTitle];
+
+const firstElement = pageArray?.[0];
+const shouldSkipFirst =
+    firstElement === '' ||
+    firstElement === siteConfig.stackName ||
+    firstElement?.toLowerCase() === 'index' ||
+    firstElement?.toLowerCase() === 'home';
+
+const newPageTitle = (pageArray && pageArray.length > 0 && firstElement)
+    ? shouldSkipFirst
+        ? pageArray.filter((a, i) => i !== 0)
+        : pageArray
+    : null;
+
+const title = newPageTitle ? `${newPageTitle.join(' | ')} | ${siteConfig.stackName}` : siteConfig.stackName;
+---
+
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <meta name="description" content={description} />
+        <meta name="generator" content={Astro.generator} />
+
+        <!-- Favicons -->
+        <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+        <link rel="apple-touch-icon" href="/apple-touch-icon.png" />
+
+        <!-- PWA manifest -->
+        <link rel="manifest" href="/manifest.webmanifest" />
+
+        <title>{title}</title>
+
+        <!-- Global styles imported from external SCSS file -->
+        <link rel="stylesheet" href="/src/styles/global.scss" />
+    </head>
+    <body>
+        <slot />
+    </body>
+</html>

package/app/src/lib/config.ts

@@ -0,0 +1,36 @@
+/**
+ * Site Configuration
+ * Central configuration for the application that will be rendered on screen
+ */
+
+/**
+ * The core stack identifier - change this in ONE place to update everywhere
+ */
+const STACK_SHORT_NAME = 'ATSDC';
+
+export const siteConfig = {
+    /**
+     * Short name for the stack (used in PWA and compact displays)
+     */
+    stackShortName: STACK_SHORT_NAME,
+
+    /**
+     * The full name of the stack/framework (derived from stackShortName)
+     */
+    stackName: `${STACK_SHORT_NAME} Stack`,
+
+    /**
+     * Full description of the stack
+     */
+    stackDescription:
+        'Full-stack application built with Astro, TypeScript, Drizzle, Clerk, and SCSS',
+
+    /**
+     * Docs URL
+     */
+    docsUrl: 'https://github.com/adarshrkumar/The-ATSDC-Stack',
+    /**
+     * GitHub repository URL
+     */
+    githubUrl: 'https://github.com/adarshrkumar/The-ATSDC-Stack',
+} as const;

package/app/src/lib/content-converter.ts

@@ -0,0 +1,141 @@
+/**
+ * Content Converter Utilities
+ * Provides functions for converting between HTML and Markdown using marked and turndown
+ */
+
+import { marked } from 'marked';
+import TurndownService from 'turndown';
+
+// Configure marked for markdown to HTML conversion
+marked.setOptions({
+    gfm: true, // GitHub Flavored Markdown
+    breaks: true, // Convert \n to <br>
+    headerIds: true, // Add IDs to headings
+    mangle: false, // Don't escape email addresses
+});
+
+// Configure turndown for HTML to markdown conversion
+const turndownService = new TurndownService({
+    headingStyle: 'atx', // Use # for headings
+    hr: '---', // Use --- for horizontal rules
+    bulletListMarker: '-', // Use - for bullet lists
+    codeBlockStyle: 'fenced', // Use ``` for code blocks
+    fence: '```', // Code fence marker
+    emDelimiter: '*', // Use * for emphasis
+    strongDelimiter: '**', // Use ** for strong
+    linkStyle: 'inlined', // Use [text](url) for links
+});
+
+/**
+ * Convert Markdown to HTML
+ * @param markdown - The markdown string to convert
+ * @returns HTML string
+ */
+export async function markdownToHtml(markdown: string): Promise<string> {
+    try {
+        const html = await marked.parse(markdown);
+        return html;
+    } catch (error) {
+        console.error('Error converting markdown to HTML:', error);
+        throw new Error('Failed to convert markdown to HTML');
+    }
+}
+
+/**
+ * Convert Markdown to HTML synchronously
+ * @param markdown - The markdown string to convert
+ * @returns HTML string
+ */
+export function markdownToHtmlSync(markdown: string): string {
+    try {
+        const html = marked.parse(markdown) as string;
+        return html;
+    } catch (error) {
+        console.error('Error converting markdown to HTML:', error);
+        throw new Error('Failed to convert markdown to HTML');
+    }
+}
+
+/**
+ * Convert HTML to Markdown
+ * @param html - The HTML string to convert
+ * @returns Markdown string
+ */
+export function htmlToMarkdown(html: string): string {
+    try {
+        const markdown = turndownService.turndown(html);
+        return markdown;
+    } catch (error) {
+        console.error('Error converting HTML to markdown:', error);
+        throw new Error('Failed to convert HTML to markdown');
+    }
+}
+
+/**
+ * Sanitize and convert Markdown to HTML
+ * Useful for user-generated content
+ * @param markdown - The markdown string to convert
+ * @returns Sanitized HTML string
+ */
+export async function sanitizeMarkdown(markdown: string): Promise<string> {
+    try {
+        // Basic sanitization - remove script tags and dangerous attributes
+        const sanitized = markdown
+            .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+            .replace(/on\w+="[^"]*"/g, '')
+            .replace(/on\w+='[^']*'/g, '');
+
+        const html = await marked.parse(sanitized);
+        return html;
+    } catch (error) {
+        console.error('Error sanitizing markdown:', error);
+        throw new Error('Failed to sanitize markdown');
+    }
+}
+
+/**
+ * Extract plain text from markdown
+ * @param markdown - The markdown string
+ * @returns Plain text string
+ */
+export function markdownToPlainText(markdown: string): string {
+    try {
+        const html = marked.parse(markdown) as string;
+        const text = html
+            .replace(/<[^>]*>/g, '') // Remove HTML tags
+            .replace(/&nbsp;/g, ' ') // Replace &nbsp;
+            .replace(/&amp;/g, '&') // Replace &amp;
+            .replace(/&lt;/g, '<') // Replace &lt;
+            .replace(/&gt;/g, '>') // Replace &gt;
+            .replace(/&quot;/g, '"') // Replace &quot;
+            .trim();
+        return text;
+    } catch (error) {
+        console.error('Error extracting plain text:', error);
+        throw new Error('Failed to extract plain text');
+    }
+}
+
+/**
+ * Generate excerpt from markdown
+ * @param markdown - The markdown string
+ * @param maxLength - Maximum length of the excerpt (default: 200)
+ * @returns Excerpt string
+ */
+export function generateExcerpt(markdown: string, maxLength: number = 200): string {
+    const plainText = markdownToPlainText(markdown);
+
+    if (plainText.length <= maxLength) {
+        return plainText;
+    }
+
+    // Truncate at word boundary
+    const truncated = plainText.slice(0, maxLength);
+    const lastSpace = truncated.lastIndexOf(' ');
+
+    if (lastSpace > 0) {
+        return truncated.slice(0, lastSpace) + '...';
+    }
+
+    return truncated + '...';
+}

package/app/src/lib/dom-utils.ts

@@ -0,0 +1,230 @@
+/**
+ * DOM Manipulation Utilities
+ * Provides functions for manipulating HTML content using Cheerio
+ */
+
+import * as cheerio from 'cheerio';
+
+/**
+ * Extract metadata from HTML content
+ * @param html - The HTML string to parse
+ * @returns Metadata object
+ */
+export function extractMetadata(html: string) {
+    const $ = cheerio.load(html);
+
+    return {
+        title: $('title').text() || $('h1').first().text() || '',
+        description: $('meta[name="description"]').attr('content') || '',
+        keywords: $('meta[name="keywords"]').attr('content') || '',
+        ogTitle: $('meta[property="og:title"]').attr('content') || '',
+        ogDescription: $('meta[property="og:description"]').attr('content') || '',
+        ogImage: $('meta[property="og:image"]').attr('content') || '',
+        twitterCard: $('meta[name="twitter:card"]').attr('content') || '',
+        canonical: $('link[rel="canonical"]').attr('href') || '',
+    };
+}
+
+/**
+ * Extract all links from HTML
+ * @param html - The HTML string to parse
+ * @returns Array of link objects
+ */
+export function extractLinks(html: string) {
+    const $ = cheerio.load(html);
+    const links: Array<{ text: string; href: string; title?: string }> = [];
+
+    $('a').each((_, element) => {
+        const $el = $(element);
+        const href = $el.attr('href');
+        if (href) {
+            links.push({
+                text: $el.text().trim(),
+                href,
+                title: $el.attr('title'),
+            });
+        }
+    });
+
+    return links;
+}
+
+/**
+ * Extract all images from HTML
+ * @param html - The HTML string to parse
+ * @returns Array of image objects
+ */
+export function extractImages(html: string) {
+    const $ = cheerio.load(html);
+    const images: Array<{ src: string; alt?: string; title?: string }> = [];
+
+    $('img').each((_, element) => {
+        const $el = $(element);
+        const src = $el.attr('src');
+        if (src) {
+            images.push({
+                src,
+                alt: $el.attr('alt'),
+                title: $el.attr('title'),
+            });
+        }
+    });
+
+    return images;
+}
+
+/**
+ * Extract headings from HTML
+ * @param html - The HTML string to parse
+ * @returns Array of heading objects
+ */
+export function extractHeadings(html: string) {
+    const $ = cheerio.load(html);
+    const headings: Array<{ level: number; text: string; id?: string }> = [];
+
+    $('h1, h2, h3, h4, h5, h6').each((_, element) => {
+        const $el = $(element);
+        const tagName = $el.prop('tagName')?.toLowerCase();
+        const level = parseInt(tagName?.replace('h', '') || '1');
+
+        headings.push({
+            level,
+            text: $el.text().trim(),
+            id: $el.attr('id'),
+        });
+    });
+
+    return headings;
+}
+
+/**
+ * Generate table of contents from HTML
+ * @param html - The HTML string to parse
+ * @param maxLevel - Maximum heading level to include (default: 3)
+ * @returns Array of TOC items
+ */
+export function generateTableOfContents(html: string, maxLevel: number = 3) {
+    const headings = extractHeadings(html);
+    return headings
+        .filter((h) => h.level <= maxLevel)
+        .map((h) => ({
+            ...h,
+            slug: h.id || h.text.toLowerCase().replace(/\s+/g, '-').replace(/[^\w-]/g, ''),
+        }));
+}
+
+/**
+ * Clean HTML content
+ * Removes scripts, styles, and other potentially dangerous elements
+ * @param html - The HTML string to clean
+ * @returns Cleaned HTML string
+ */
+export function cleanHtml(html: string): string {
+    const $ = cheerio.load(html);
+
+    // Remove dangerous elements
+    $('script, style, iframe, object, embed').remove();
+
+    // Remove event handlers
+    $('*').each((_, element) => {
+        const $el = $(element);
+        const attrs = $el.attr();
+
+        if (attrs) {
+            Object.keys(attrs).forEach((attr) => {
+                if (attr.startsWith('on')) {
+                    $el.removeAttr(attr);
+                }
+            });
+        }
+    });
+
+    return $.html();
+}
+
+/**
+ * Extract text content from HTML
+ * @param html - The HTML string to parse
+ * @returns Plain text string
+ */
+export function extractTextContent(html: string): string {
+    const $ = cheerio.load(html);
+
+    // Remove script and style elements
+    $('script, style').remove();
+
+    return $('body').text().replace(/\s+/g, ' ').trim();
+}
+
+/**
+ * Add IDs to headings for anchor linking
+ * @param html - The HTML string to process
+ * @returns HTML with IDs added to headings
+ */
+export function addHeadingIds(html: string): string {
+    const $ = cheerio.load(html);
+
+    $('h1, h2, h3, h4, h5, h6').each((_, element) => {
+        const $el = $(element);
+
+        if (!$el.attr('id')) {
+            const text = $el.text().trim();
+            const id = text.toLowerCase().replace(/\s+/g, '-').replace(/[^\w-]/g, '');
+            $el.attr('id', id);
+        }
+    });
+
+    return $.html();
+}
+
+/**
+ * Add target="_blank" to external links
+ * @param html - The HTML string to process
+ * @param domain - The current domain (optional)
+ * @returns HTML with external links updated
+ */
+export function addExternalLinkTargets(html: string, domain?: string): string {
+    const $ = cheerio.load(html);
+
+    $('a').each((_, element) => {
+        const $el = $(element);
+        const href = $el.attr('href');
+
+        if (href && (href.startsWith('http://') || href.startsWith('https://'))) {
+            if (!domain || !href.includes(domain)) {
+                $el.attr('target', '_blank');
+                $el.attr('rel', 'noopener noreferrer');
+            }
+        }
+    });
+
+    return $.html();
+}
+
+/**
+ * Calculate reading time for HTML content
+ * @param html - The HTML string to analyze
+ * @param wordsPerMinute - Average reading speed (default: 200)
+ * @returns Reading time in minutes
+ */
+export function calculateReadingTime(html: string, wordsPerMinute: number = 200): number {
+    const text = extractTextContent(html);
+    const wordCount = text.split(/\s+/).length;
+    return Math.ceil(wordCount / wordsPerMinute);
+}
+
+/**
+ * Wrap tables in a responsive container
+ * @param html - The HTML string to process
+ * @returns HTML with tables wrapped
+ */
+export function wrapTables(html: string): string {
+    const $ = cheerio.load(html);
+
+    $('table').each((_, element) => {
+        const $el = $(element);
+        $el.wrap('<div class="table-wrapper" style="overflow-x: auto;"></div>');
+    });
+
+    return $.html();
+}