@leadertechie/personal-site-kit 0.1.0-alpha.8 → 0.1.0-alpha.9

package/src/api/website-api.ts

@@ -1,142 +0,0 @@
-import { createErrorResponse } from './utils';
-import { handleAboutMe, clearContentCache } from './handlers/about-me';
-import { handleHome } from './handlers/home';
-import { handleInfo } from './handlers/info';
-import { handleContent } from './handlers/content';
-import { handleAuth } from './handlers/auth-handler';
-import { handleBlogs, handleStories, handleSearch } from './handlers/content-api';
-import { handleLogo } from './handlers/logo';
-import { handleStaticDetails } from './handlers/static-details';
-import { getAuthStore } from './handlers/auth';
-
-export type APIHandler = (request: Request, env: any) => Promise<Response>;
-
-export class WebsiteAPI {
-  private customHandlers = new Map<string, APIHandler>();
-
-  public registerHandler(route: string, handler: APIHandler) {
-    this.customHandlers.set(route, handler);
-  }
-
-  private addCORSHeaders(response: Response): Response {
-    response.headers.set('Access-Control-Allow-Origin', '*' );
-    response.headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS' );
-    response.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Session-Token');
-    return response;
-  }
-
-  private addAdminCORSHeaders(response: Response, origin: string): Response {
-    const allowOrigin = origin && (origin.includes('localhost') || origin.includes('127.0.0.1')) 
-      ? origin 
-      : 'same-origin';
-    response.headers.set('Access-Control-Allow-Origin', allowOrigin);
-    response.headers.set('Access-Control-Allow-Credentials', 'true');
-    response.headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
-    response.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Session-Token');
-    return response;
-  }
-
-  private handleCORS(origin: string): Response {
-    const allowOrigin = origin && (origin.includes('localhost') || origin.includes('127.0.0.1')) 
-      ? origin 
-      : '*';
-    return new Response(null, {
-      status: 200,
-      headers: {
-        'Access-Control-Allow-Origin': allowOrigin ,
-        'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS' ,
-        'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Session-Token',
-        'Access-Control-Allow-Credentials': 'true',
-        'Access-Control-Max-Age': '86400',
-      },
-    });
-  }
-
-  public async fetch(request: Request, env: any): Promise<Response> {
-    const url = new URL(request.url);
-    const origin = request.headers.get('Origin') || url.origin;
-
-    if (request.method === 'OPTIONS') {
-      return this.handleCORS(origin);
-    }
-
-    const pathname = url.pathname;
-    const route = pathname
-      .replace(/^\/api\//, '')
-      .replace(/^\//, '')
-      .replace(/\/+$/, '');
-
-    // Check custom handlers first
-    if (this.customHandlers.has(route)) {
-      const handler = this.customHandlers.get(route)!;
-      return this.addCORSHeaders(await handler(request, env));
-    }
-
-    try {
-      // Check for content route first (content/*)
-      if (route === 'content' || route.startsWith('content/')) {
-        const subpath = route.replace(/^content\/?/, '');
-        return this.addAdminCORSHeaders(await handleContent(request, env, subpath), origin);
-      }
-
-      // Check for auth route (auth/*)
-      if (route === 'auth' || route.startsWith('auth/')) {
-        const subpath = route.replace(/^auth\/?/, '');
-        return this.addAdminCORSHeaders(await handleAuth(request, env, subpath || '/'), origin);
-      }
-
-      switch (route) {
-        case 'info':
-          return this.addCORSHeaders(await handleInfo());
-        case 'home':
-          return this.addCORSHeaders(await handleHome(env));
-        case 'cache-clear':
-          const cookieHeader = request.headers.get('Cookie');
-          const sessionToken = cookieHeader?.split(';')
-            .find(c => c.trim().startsWith('session='))
-            ?.split('=')[1];
-          const session = sessionToken ? await env.KV.get(`session:${sessionToken}`, 'json') : null;
-          if (!session || session.expiresAt < Date.now()) {
-            return this.addAdminCORSHeaders(createErrorResponse('Unauthorized', 401), origin);
-          }
-          clearContentCache();
-          return this.addAdminCORSHeaders(new Response(JSON.stringify({ success: true, message: 'Cache cleared' }), { status: 200 }), origin);
-        case 'aboutme':
-          return this.addCORSHeaders(await handleAboutMe(env));
-        case 'logo':
-          return this.addCORSHeaders(await handleLogo(env));
-        case 'static':
-          return this.addCORSHeaders(await handleStaticDetails(env));
-        case 'blogs':
-          return this.addCORSHeaders(await handleBlogs(env));
-        case 'blogs/latest':
-          const latestCount = url.searchParams.get('count');
-          return this.addCORSHeaders(await handleBlogs(env, undefined, latestCount ? parseInt(latestCount) : 5));
-        default:
-          if (route.startsWith('blogs/')) {
-            const slug = route.replace('blogs/', '');
-            return this.addCORSHeaders(await handleBlogs(env, slug));
-          }
-          if (route.startsWith('stories')) {
-            if (route === 'stories') {
-              return this.addCORSHeaders(await handleStories(env));
-            }
-            if (route === 'stories/latest') {
-              const latestCount = url.searchParams.get('count');
-              return this.addCORSHeaders(await handleStories(env, undefined, latestCount ? parseInt(latestCount) : 5));
-            }
-            const slug = route.replace('stories/', '');
-            return this.addCORSHeaders(await handleStories(env, slug));
-          }
-          if (route === 'search') {
-            const query = url.searchParams.get('q');
-            return this.addCORSHeaders(await handleSearch(env, query || undefined));
-          }
-          return this.addCORSHeaders(createErrorResponse('Route not found', 404));
-      }
-    } catch (error) {
-      console.error('API Error:', error);
-      return this.addCORSHeaders(createErrorResponse('Internal server error', 500));
-    }
-  }
-}

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from './api';
-export * from './prerender';
-export * from './ui';
-export * from './shared';

package/src/prerender/__tests__/page-content.test.ts

@@ -1,44 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { generatePageContent } from '../page-content';
-
-describe('generatePageContent', () => {
-  const mockRoutes = [
-    { link: '/', text: 'Home' },
-    { link: '/about-me', text: 'About' }
-  ];
-  const mockFooterLinks = [
-    { text: 'Link', link: '#' }
-  ];
-  const mockEnv = {
-    apiUrl: 'https://api.example.com',
-    baseUrl: 'https://www.example.com'
-  };
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should generate home page content', async () => {
-    const result = await generatePageContent('/', mockRoutes, mockFooterLinks, mockEnv);
-
-    expect(result.title).toContain('User');
-    expect(result.canonicalUrl).toBe('https://www.example.com/');
-    expect(result.content).toContain('<my-banner');
-  });
-
-  it('should generate about-me page content', async () => {
-    const result = await generatePageContent('/about-me', mockRoutes, mockFooterLinks, mockEnv);
-
-    expect(result.title).toContain('About');
-    expect(result.canonicalUrl).toBe('https://www.example.com/about-me');
-    expect(result.content).toContain('<my-aboutme');
-  });
-
-  it('should generate 404 page content', async () => {
-    const result = await generatePageContent('/non-existent', mockRoutes, mockFooterLinks, mockEnv);
-
-    expect(result.title).toContain('Not Found');
-    expect(result.canonicalUrl).toBe('https://www.example.com/non-existent');
-    expect(result.content).toContain('Page Not Found');
-  });
-});

package/src/prerender/__tests__/template.test.ts

@@ -1,54 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createHtmlTemplate } from '../template';
-
-describe('createHtmlTemplate', () => {
-  it('should generate complete HTML template', async () => {
-    const props = {
-      title: 'Test Title',
-      description: 'Test Description',
-      canonicalUrl: 'https://example.com/test',
-      content: '<main>Test Content</main>'
-    };
-
-    const html = await createHtmlTemplate(props);
-
-    expect(html).toContain('<!doctype html>');
-    expect(html).toContain('<title>Test Title</title>');
-    expect(html).toContain('<meta name="description" content="Test Description" />');
-    expect(html).toContain('<meta property="og:title" content="Test Title" />');
-    expect(html).toContain('<link rel="canonical" href="https://example.com/test" />');
-    expect(html).toContain('<main>Test Content</main>');
-  });
-
-  it('should escape HTML entities properly', async () => {
-    const props = {
-      title: 'Test & Title',
-      description: 'Test "Description"',
-      canonicalUrl: 'https://example.com/test',
-      content: '<main>Test Content</main>'
-    };
-
-    const html = await createHtmlTemplate(props);
-
-    expect(html).toContain('<title>Test & Title</title>');
-    expect(html).toContain('<meta name="description" content="Test "Description"" />');
-  });
-
-  it('should have proper HTML structure', async () => {
-    const props = {
-      title: 'Test',
-      description: 'Test',
-      canonicalUrl: 'https://example.com',
-      content: '<div>Content</div>'
-    };
-
-    const html = await createHtmlTemplate(props);
-
-    expect(html).toMatch(/^<!doctype html>/);
-    expect(html).toContain('<html lang="en" data-theme="light">');
-    expect(html).toContain('<head>');
-    expect(html).toContain('<body>');
-    expect(html).toContain('<div id="app">');
-    expect(html).toContain('</html>');
-  });
-});

package/src/prerender/data-fetcher.ts

@@ -1,93 +0,0 @@
-import { R2ContentLoader } from "@leadertechie/r2tohtml";
-
-export interface Profile {
-  name: string;
-  title: string;
-  experience: string;
-  profileImageUrl: string;
-}
-
-export interface BlogMeta {
-  slug: string;
-  title: string;
-  summary: string;
-  tags: string[];
-  date: string;
-}
-
-let loader: R2ContentLoader | null = null;
-
-function getLoader(env: any): R2ContentLoader | null {
-  if (!loader) {
-    if (!env?.CONTENT_BUCKET) return null;
-    loader = new R2ContentLoader(
-      { bucket: env.CONTENT_BUCKET, cacheTTL: 5 * 60 * 1000 },
-      { md2html: { imagePathPrefix: "images/", styleOptions: { classPrefix: "md-", addHeadingIds: true } } }
-    );
-  }
-  return loader;
-}
-
-export async function fetchProfile(env: any): Promise<Profile | null> {
-  try {
-    const r2 = getLoader(env);
-    if (!r2) return null;
-    const obj = await r2.getObject("profile.json");
-    if (!obj) return null;
-    return await obj.json() as Profile;
-  } catch { return null; }
-}
-
-export async function fetchAboutMe(env: any): Promise<string> {
-  try {
-    const r2 = getLoader(env);
-    if (!r2) return "";
-    const result = await r2.getRendered("about-me.md");
-    return result?.content || "";
-  } catch { return ""; }
-}
-
-export async function fetchHome(env: any): Promise<string> {
-  try {
-    const r2 = getLoader(env);
-    if (!r2) return "";
-    const result = await r2.getRendered("pages/home.md");
-    return result?.content || "";
-  } catch { return ""; }
-}
-
-export async function fetchLatestBlogSummaries(env: any, count: number = 3): Promise<BlogMeta[]> {
-  try {
-    const r2 = getLoader(env);
-    if (!r2) return [];
-    const list = await r2.list("blogs/");
-    const metas: BlogMeta[] = [];
-    for (const obj of list.objects) {
-      if (obj.key.endsWith(".json")) {
-        try {
-          const metaObj = await r2.getObject(obj.key);
-          if (metaObj) metas.push(await metaObj.json() as BlogMeta);
-        } catch {}
-      }
-    }
-    return metas.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()).slice(0, count);
-  } catch { return []; }
-}
-
-export async function fetchLatestStorySummaries(env: any, count: number = 3): Promise<BlogMeta[]> {
-  try {
-    const r2 = getLoader(env);
-    if (!r2) return [];
-    const list = await r2.list("stories/");
-    const metas: BlogMeta[] = [];
-    for (const obj of list.objects) {
-      if (obj.key.endsWith(".json")) {
-        try {
-          const metaObj = await r2.getObject(obj.key);
-          if (metaObj) metas.push(await metaObj.json() as BlogMeta);
-        } catch {}
-      }
-    }
-    return metas.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()).slice(0, count);
-  } catch { return []; }
-}

package/src/prerender/index.ts

@@ -1,7 +0,0 @@
-import { WebsitePrerender } from './website-prerender';
-export { WebsitePrerender };
-export type { PrerenderOptions } from './website-prerender';
-
-// Default worker export using WebsitePrerender
-const defaultPrerender = new WebsitePrerender();
-export default defaultPrerender;

package/src/prerender/page-content.ts

@@ -1,266 +0,0 @@
-import { R2ContentLoader } from "@leadertechie/r2tohtml";
-
-interface Profile {
-  name: string;
-  title: string;
-  experience: string;
-  profileImageUrl: string;
-}
-
-export interface IRoute {
-  text: string;
-  link: string;
-}
-
-export interface IFooterLink {
-  text: string;
-  link: string;
-}
-
-export interface PageContent {
-  title: string;
-  description: string;
-  canonicalUrl: string;
-  content: string;
-}
-
-interface BlogMeta {
-  slug: string;
-  title: string;
-  summary: string;
-  tags: string[];
-  date: string;
-}
-
-let loader: R2ContentLoader | null = null;
-
-function getLoader(env: any): R2ContentLoader | null {
-  if (!loader) {
-    if (!env?.CONTENT_BUCKET) return null;
-    loader = new R2ContentLoader(
-      { bucket: env.CONTENT_BUCKET, cacheTTL: 5 * 60 * 1000 },
-      { md2html: { imagePathPrefix: "images/", styleOptions: { classPrefix: "md-", addHeadingIds: true } } }
-    );
-  }
-  return loader;
-}
-
-async function fetchProfile(env: any): Promise<Profile | null> {
-  try {
-    const r2 = getLoader(env);
-    if (!r2) return null;
-    const obj = await r2.getObject("profile.json");
-    if (!obj) return null;
-    return await obj.json() as Profile;
-  } catch { return null; }
-}
-
-async function fetchAboutMe(env: any): Promise<string> {
-  try {
-    const r2 = getLoader(env);
-    if (!r2) return "";
-    const result = await r2.getRendered("about-me.md");
-    return result?.content || "";
-  } catch { return ""; }
-}
-
-async function fetchHome(env: any): Promise<string> {
-  try {
-    const r2 = getLoader(env);
-    if (!r2) return "";
-    const result = await r2.getRendered("pages/home.md");
-    return result?.content || "";
-  } catch { return ""; }
-}
-
-async function fetchLatestBlogSummaries(env: any, count: number = 3): Promise<BlogMeta[]> {
-  try {
-    const r2 = getLoader(env);
-    if (!r2) return [];
-    const list = await r2.list("blogs/");
-    const metas: BlogMeta[] = [];
-    for (const obj of list.objects) {
-      if (obj.key.endsWith(".json")) {
-        try {
-          const metaObj = await r2.getObject(obj.key);
-          if (metaObj) metas.push(await metaObj.json() as BlogMeta);
-        } catch {}
-      }
-    }
-    return metas.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()).slice(0, count);
-  } catch { return []; }
-}
-
-async function fetchLatestStorySummaries(env: any, count: number = 3): Promise<BlogMeta[]> {
-  try {
-    const r2 = getLoader(env);
-    if (!r2) return [];
-    const list = await r2.list("stories/");
-    const metas: BlogMeta[] = [];
-    for (const obj of list.objects) {
-      if (obj.key.endsWith(".json")) {
-        try {
-          const metaObj = await r2.getObject(obj.key);
-          if (metaObj) metas.push(await metaObj.json() as BlogMeta);
-        } catch {}
-      }
-    }
-    return metas.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()).slice(0, count);
-  } catch { return []; }
-}
-
-export const generatePageContent = async (
-  pathname: string,
-  routes: IRoute[],
-  footerLinks: IFooterLink[],
-  env?: any
-): Promise<PageContent> => {
-  const apiUrl = env?.API_URL || env?.apiUrl || "https://api.example.com";
-  const baseUrl = env?.BASE_URL || env?.baseUrl || "https://www.example.com";
-  
-  let staticDetails = {
-    siteTitle: "My Personal Website",
-    copyright: "2026 My Personal Website",
-    linkedin: "https://linkedin.com/in/yourname",
-    github: "https://github.com/yourname",
-    email: "yourname@domain.com"
-  };
-  
-  try {
-    const res = await fetch(`${apiUrl}/api/static`);
-    if (res.ok) staticDetails = await res.json();
-  } catch (e) {}
-  
-  let profile: Profile | null = null;
-  let aboutMeContent = "";
-  let homeContent = "";
-  let latestBlogs: BlogMeta[] = [];
-  let latestStories: BlogMeta[] = [];
-
-  if (env?.CONTENT_BUCKET) {
-    [profile, aboutMeContent, homeContent, latestBlogs, latestStories] = await Promise.all([
-      fetchProfile(env), fetchAboutMe(env), fetchHome(env), fetchLatestBlogSummaries(env, 3), fetchLatestStorySummaries(env, 3)
-    ]);
-  }
-
-  const name = profile?.name || "User";
-  const title = profile?.title || "Professional";
-  const canonicalUrl = new URL(pathname, baseUrl).toString();
-
-  // Strategy pattern: map pathname patterns to generators
-  const strategies = {
-    home: async () => {
-      const { HomePageGenerator } = await import('./page-generators');
-      const generator = new HomePageGenerator();
-      return generator.generate({
-        routes,
-        footerLinks,
-        staticDetails,
-        apiUrl,
-        baseUrl,
-        pathname,
-        profile,
-        homeContent,
-        latestBlogs,
-        latestStories
-      });
-    },
-    about: async () => {
-      const { AboutPageGenerator } = await import('./page-generators');
-      const generator = new AboutPageGenerator();
-      return generator.generate({
-        routes,
-        footerLinks,
-        staticDetails,
-        apiUrl,
-        baseUrl,
-        pathname,
-        profile
-      });
-    },
-    blogsList: async () => {
-      const { BlogsListPageGenerator } = await import('./page-generators');
-      const generator = new BlogsListPageGenerator();
-      return generator.generate({
-        routes,
-        footerLinks,
-        staticDetails,
-        apiUrl,
-        baseUrl,
-        pathname,
-        latestBlogs,
-        name
-      });
-    },
-    storiesList: async () => {
-      const { StoriesListPageGenerator } = await import('./page-generators');
-      const generator = new StoriesListPageGenerator();
-      return generator.generate({
-        routes,
-        footerLinks,
-        staticDetails,
-        apiUrl,
-        baseUrl,
-        pathname,
-        latestStories,
-        name
-      });
-    },
-    blogDetail: async (slug: string) => {
-      const { BlogDetailPageGenerator } = await import('./page-generators');
-      const generator = new BlogDetailPageGenerator();
-      return generator.generate({
-        routes,
-        footerLinks,
-        staticDetails,
-        apiUrl,
-        baseUrl,
-        pathname,
-        slug
-      });
-    },
-    storyDetail: async (slug: string) => {
-      const { StoryDetailPageGenerator } = await import('./page-generators');
-      const generator = new StoryDetailPageGenerator();
-      return generator.generate({
-        routes,
-        footerLinks,
-        staticDetails,
-        apiUrl,
-        baseUrl,
-        pathname,
-        slug
-      });
-    },
-    notFound: async () => {
-      const { NotFoundPageGenerator } = await import('./page-generators');
-      const generator = new NotFoundPageGenerator();
-      return generator.generate({
-        routes,
-        footerLinks,
-        staticDetails,
-        apiUrl,
-        baseUrl,
-        pathname
-      });
-    }
-  };
-
-  if (pathname === "/" || pathname === "") {
-    return strategies.home();
-  } else if (pathname === "/about-me") {
-    return strategies.about();
-  } else if (pathname === "/blogs" || pathname === "/blogs/") {
-    return strategies.blogsList();
-  } else if (pathname === "/stories" || pathname === "/stories/") {
-    return strategies.storiesList();
-  } else if (pathname.startsWith("/blogs/")) {
-    const slug = pathname.replace("/blogs/", "").replace("/", "");
-    return strategies.blogDetail(slug);
-  } else if (pathname.startsWith("/stories/")) {
-    const slug = pathname.replace("/stories/", "").replace("/", "");
-    return strategies.storyDetail(slug);
-  } else {
-    return strategies.notFound();
-  }
-};

package/src/prerender/page-generators/about.ts

@@ -1,38 +0,0 @@
-import { BasePageGenerator, StaticDetails } from './base';
-import { IRoute, IFooterLink, PageContent } from '../page-content';
-import { Profile } from '../data-fetcher';
-
-export interface AboutPageData {
-  routes: IRoute[];
-  footerLinks: IFooterLink[];
-  staticDetails: StaticDetails;
-  apiUrl: string;
-  baseUrl: string;
-  pathname: string;
-  profile: Profile | null;
-}
-
-export class AboutPageGenerator extends BasePageGenerator {
-  public generate(data: AboutPageData): PageContent {
-    const { profile, staticDetails, ...baseData } = data;
-
-    const name = profile?.name || "User";
-
-    const mainContent = `
-      <main class="container container-narrow">
-        <my-aboutme base-url="${baseData.apiUrl}"></my-aboutme>
-      </main>`;
-
-    return this.generatePage(
-      baseData.pathname,
-      baseData.routes,
-      baseData.footerLinks,
-      staticDetails,
-      baseData.apiUrl,
-      baseData.baseUrl,
-      mainContent,
-      `About - ${name}`,
-      `Learn more about ${name}'s experience and skills.`
-    );
-  }
-}