@foliokit/cms-core 1.0.0 → 1.0.1

package/src/lib/models/site-config.model.ts

@@ -0,0 +1,103 @@
+import type { SeoMeta } from './post.model';
+import type { LinksLink } from './page.model';
+
+export type { SeoMeta };
+
+export interface NavItem {
+  label: string;
+  url: string;
+  order?: number;
+  external?: boolean;
+  icon?: string;
+}
+
+export interface NavGroup {
+  group: string;
+  items: NavItem[];
+}
+
+export type NavEntry = NavItem | NavGroup;
+
+export function isNavGroup(entry: NavEntry): entry is NavGroup {
+  return 'group' in entry && 'items' in entry;
+}
+
+export type SocialPlatform =
+  | 'twitter'
+  | 'instagram'
+  | 'github'
+  | 'linkedin'
+  | 'youtube'
+  | 'twitch'
+  | 'bluesky'
+  | 'tiktok'
+  | 'facebook'
+  | 'email'
+  | 'website';
+
+export interface SocialLink {
+  platform: SocialPlatform;
+  url: string;
+  label?: string;
+  icon?: string;
+}
+
+export interface AboutPageConfig {
+  enabled: boolean;
+  headline: string;
+  subheadline?: string;
+  /** Markdown — rendered via MarkdownComponent */
+  bio: string;
+  /** Firebase Storage URL */
+  photoUrl?: string;
+  /** Firebase Storage URL — shown in dark mode when set */
+  photoUrlDark?: string;
+  photoAlt?: string;
+  socialLinks?: SocialLink[];
+  seo?: SeoMeta;
+}
+
+export interface LinksPageConfig {
+  enabled: boolean;
+  links?: LinksLink[];
+  title?: string;
+  avatarUrl?: string;
+  avatarUrlDark?: string;
+  avatarAlt?: string;
+  headline?: string;
+  bio?: string;
+  seo?: SeoMeta;
+}
+
+export interface HomePageConfig {
+  enabled: boolean;
+  heroHeadline: string;
+  heroSubheadline?: string;
+  ctaLabel?: string;
+  ctaUrl?: string;
+  showRecentPosts?: boolean;
+  seo?: SeoMeta;
+}
+
+export interface SiteConfig {
+  id: string;
+  siteName: string;
+  siteUrl: string;
+  description?: string;
+  logo?: string;
+  favicon?: string;
+  nav: NavItem[];
+  defaultAuthorId?: string;
+  defaultSeo?: SeoMeta;
+  pages?: {
+    home?: HomePageConfig;
+    about?: AboutPageConfig;
+    links?: LinksPageConfig;
+  };
+  /** Set to true once the admin has completed the setup wizard. Never reset. */
+  setupComplete?: boolean;
+  /** Step IDs the admin has explicitly saved in the setup wizard (tracks optional step acknowledgment). */
+  setupAcknowledgedSteps?: string[];
+  /** Unix milliseconds. */
+  updatedAt: number;
+}

package/src/lib/models/tag.model.ts

@@ -0,0 +1,5 @@
+export interface Tag {
+  id: string;
+  label: string;
+  slug: string;
+}

package/src/lib/pipes/tag-label.pipe.ts

@@ -0,0 +1,16 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import type { Tag } from '../models/tag.model';
+
+function humanizeSlug(slug: string): string {
+  return slug
+    .replace(/^tag-/, '')
+    .replace(/-/g, ' ')
+    .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+@Pipe({ name: 'tagLabel', standalone: true, pure: true })
+export class TagLabelPipe implements PipeTransform {
+  transform(tagId: string, lookup?: Map<string, Tag>): string {
+    return lookup?.get(tagId)?.label ?? humanizeSlug(tagId);
+  }
+}

package/src/lib/resolvers/about-page.resolver.ts

@@ -0,0 +1,76 @@
+import { inject, makeStateKey, PLATFORM_ID, TransferState } from '@angular/core';
+import { isPlatformServer } from '@angular/common';
+import { ResolveFn, Router } from '@angular/router';
+import { map, tap, take } from 'rxjs/operators';
+import { SITE_CONFIG_SERVICE } from '../tokens/site-config-service.token';
+import type { AboutPageConfig } from '../models/site-config.model';
+
+const ABOUT_PAGE_KEY = makeStateKey<AboutPageConfig | null>('about-page');
+
+/** Options for {@link createAboutPageResolver}. */
+export interface AboutPageResolverOptions {
+  /**
+   * Route to redirect to when about page config is absent or has no `bio`.
+   * @default '/not-found'
+   */
+  notFoundRoute?: string;
+}
+
+/**
+ * Factory that creates a resolver for the About page.
+ *
+ * Reads `AboutPageConfig` from `SITE_CONFIG_SERVICE.getAboutConfig()`, using
+ * Angular's `TransferState` to avoid a duplicate Firestore read on browser
+ * hydration after SSR. Redirects to `notFoundRoute` (default: `/not-found`)
+ * when the config is absent or has no `bio` field.
+ *
+ * `SITE_CONFIG_SERVICE` must be provided in your app — either the default
+ * `SiteConfigService` (client SDK) or a server-side override (Admin SDK) via
+ * `app.config.server.ts`.
+ *
+ * @example
+ * ```ts
+ * // app.routes.ts
+ * {
+ *   path: 'about',
+ *   resolve: { about: createAboutPageResolver() },
+ *   loadComponent: () => import('./about/about.component').then(m => m.AboutComponent),
+ * }
+ * ```
+ */
+export function createAboutPageResolver(
+  options?: AboutPageResolverOptions,
+): ResolveFn<AboutPageConfig> {
+  const notFoundRoute = options?.notFoundRoute ?? '/not-found';
+
+  return () => {
+    const transferState = inject(TransferState);
+    const service = inject(SITE_CONFIG_SERVICE);
+    const platformId = inject(PLATFORM_ID);
+    const router = inject(Router);
+
+    if (transferState.hasKey(ABOUT_PAGE_KEY)) {
+      const about = transferState.get(ABOUT_PAGE_KEY, null);
+      transferState.remove(ABOUT_PAGE_KEY);
+      if (!about || !about.bio) {
+        return router.createUrlTree([notFoundRoute]) as never;
+      }
+      return about;
+    }
+
+    return service.getAboutConfig().pipe(
+      take(1),
+      tap((about) => {
+        if (isPlatformServer(platformId)) {
+          transferState.set(ABOUT_PAGE_KEY, about);
+        }
+      }),
+      map((about) => {
+        if (!about || !about.bio) {
+          return router.createUrlTree([notFoundRoute]) as never;
+        }
+        return about;
+      }),
+    );
+  };
+}

package/src/lib/resolvers/links-page.resolver.ts

@@ -0,0 +1,77 @@
+import { inject, makeStateKey, PLATFORM_ID, TransferState } from '@angular/core';
+import { isPlatformServer } from '@angular/common';
+import { ResolveFn, Router } from '@angular/router';
+import { map, tap, take } from 'rxjs/operators';
+import { SITE_CONFIG_SERVICE } from '../tokens/site-config-service.token';
+import type { LinksPageConfig } from '../models/site-config.model';
+
+const LINKS_PAGE_KEY = makeStateKey<LinksPageConfig | null>('links-page');
+
+/** Options for {@link createLinksPageResolver}. */
+export interface LinksPageResolverOptions {
+  /**
+   * Route to redirect to when links page config is absent or has no links.
+   * @default '/not-found'
+   */
+  notFoundRoute?: string;
+}
+
+/**
+ * Factory that creates a resolver for the Links page.
+ *
+ * Reads `LinksPageConfig` from `SITE_CONFIG_SERVICE.getConfig().pages.links`,
+ * using Angular's `TransferState` to avoid a duplicate Firestore read on
+ * browser hydration after SSR. Redirects to `notFoundRoute` (default:
+ * `/not-found`) when the config is absent or the `links` array is empty.
+ *
+ * `SITE_CONFIG_SERVICE` must be provided in your app — either the default
+ * `SiteConfigService` (client SDK) or a server-side override (Admin SDK) via
+ * `app.config.server.ts`.
+ *
+ * @example
+ * ```ts
+ * // app.routes.ts
+ * {
+ *   path: 'links',
+ *   resolve: { page: createLinksPageResolver() },
+ *   loadComponent: () => import('@foliokit/cms-ui').then(m => m.LinksPageComponent),
+ * }
+ * ```
+ */
+export function createLinksPageResolver(
+  options?: LinksPageResolverOptions,
+): ResolveFn<LinksPageConfig> {
+  const notFoundRoute = options?.notFoundRoute ?? '/not-found';
+
+  return () => {
+    const transferState = inject(TransferState);
+    const service = inject(SITE_CONFIG_SERVICE);
+    const platformId = inject(PLATFORM_ID);
+    const router = inject(Router);
+
+    if (transferState.hasKey(LINKS_PAGE_KEY)) {
+      const links = transferState.get(LINKS_PAGE_KEY, null);
+      transferState.remove(LINKS_PAGE_KEY);
+      if (!links || !links.links?.length) {
+        return router.createUrlTree([notFoundRoute]) as never;
+      }
+      return links;
+    }
+
+    return service.getConfig().pipe(
+      take(1),
+      tap((config) => {
+        if (isPlatformServer(platformId)) {
+          transferState.set(LINKS_PAGE_KEY, config.pages?.links ?? null);
+        }
+      }),
+      map((config) => {
+        const links = config.pages?.links;
+        if (!links || !links.links?.length) {
+          return router.createUrlTree([notFoundRoute]) as never;
+        }
+        return links;
+      }),
+    );
+  };
+}

package/src/lib/resolvers/posts.resolver.ts

@@ -0,0 +1,51 @@
+import { inject, PLATFORM_ID, TransferState } from '@angular/core';
+import { isPlatformServer } from '@angular/common';
+import { ResolveFn } from '@angular/router';
+import { take, tap } from 'rxjs/operators';
+import { BLOG_POST_SERVICE, POSTS_TRANSFER_KEY } from '../tokens/post-service.token';
+import type { BlogPost } from '../models/post.model';
+
+/**
+ * Factory that creates a resolver for the published posts list.
+ *
+ * Reads all published posts from `BLOG_POST_SERVICE.getPublishedPosts()`,
+ * using Angular's `TransferState` (`POSTS_TRANSFER_KEY`) to avoid a duplicate
+ * Firestore read on browser hydration after SSR. Always resolves to an array
+ * (empty on error or when no posts are published).
+ *
+ * `BLOG_POST_SERVICE` must be provided in your app — either the default
+ * `PostService` (client SDK) or a server-side override (Admin SDK) via
+ * `app.config.server.ts`.
+ *
+ * @example
+ * ```ts
+ * // app.routes.ts
+ * {
+ *   path: 'posts',
+ *   resolve: { posts: createPostsResolver() },
+ *   loadComponent: () => import('./post-list/post-list.component').then(m => m.PostListComponent),
+ * }
+ * ```
+ */
+export function createPostsResolver(): ResolveFn<BlogPost[]> {
+  return () => {
+    const transferState = inject(TransferState);
+    const service = inject(BLOG_POST_SERVICE);
+    const platformId = inject(PLATFORM_ID);
+
+    if (transferState.hasKey(POSTS_TRANSFER_KEY)) {
+      const posts = transferState.get(POSTS_TRANSFER_KEY, []);
+      transferState.remove(POSTS_TRANSFER_KEY);
+      return posts;
+    }
+
+    return service.getPublishedPosts().pipe(
+      take(1),
+      tap((posts) => {
+        if (isPlatformServer(platformId)) {
+          transferState.set(POSTS_TRANSFER_KEY, posts);
+        }
+      }),
+    );
+  };
+}

package/src/lib/services/auth.service.ts

@@ -0,0 +1,49 @@
+import { computed, inject, Injectable } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { Observable } from 'rxjs';
+import {
+  GoogleAuthProvider,
+  onAuthStateChanged,
+  signInWithPopup,
+  signOut,
+  User,
+} from 'firebase/auth';
+import { ADMIN_EMAIL, FIREBASE_AUTH } from '../firebase/firebase.config';
+
+@Injectable({ providedIn: 'root' })
+export class AuthService {
+  private readonly auth = inject(FIREBASE_AUTH);
+  private readonly adminEmail = inject(ADMIN_EMAIL, { optional: true });
+
+  readonly user = toSignal(
+    new Observable<User | null>((subscriber) => {
+      if (!this.auth) {
+        subscriber.next(null);
+        subscriber.complete();
+        return;
+      }
+      return onAuthStateChanged(this.auth, (u) => subscriber.next(u));
+    }),
+    { requireSync: false, initialValue: undefined },
+  );
+
+  readonly isAuthenticated = computed(() => this.user() != null);
+
+  readonly isAdmin = computed(() => {
+    const email = this.user()?.email;
+    if (!email) return false;
+    return this.adminEmail ? email === this.adminEmail : false;
+  });
+
+  async signInWithGoogle(): Promise<void> {
+    if (!this.auth) return;
+    const provider = new GoogleAuthProvider();
+    provider.setCustomParameters({ prompt: 'login' });
+    await signInWithPopup(this.auth, provider);
+  }
+
+  async signOut(): Promise<void> {
+    if (!this.auth) return;
+    await signOut(this.auth);
+  }
+}

package/src/lib/services/author.service.ts

@@ -0,0 +1,88 @@
+import { inject, Injectable } from '@angular/core';
+import {
+  collection,
+  deleteDoc,
+  doc,
+  getDoc,
+  getDocs,
+  orderBy,
+  query,
+  setDoc,
+  Timestamp,
+  updateDoc,
+} from 'firebase/firestore';
+import { from, Observable, of } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { FIRESTORE } from '../firebase/firebase.config';
+import type { Author } from '../models/author.model';
+import { normalizeAuthor } from '../utils/normalize-author';
+
+@Injectable({ providedIn: 'root' })
+export class AuthorService {
+  private readonly firestore = inject(FIRESTORE)!;
+
+  getAll(): Observable<Author[]> {
+    const q = query(
+      collection(this.firestore, 'authors'),
+      orderBy('displayName', 'asc'),
+    );
+    return from(getDocs(q)).pipe(
+      map((snapshot) =>
+        snapshot.docs.map((d) => normalizeAuthor({ id: d.id, ...d.data() })),
+      ),
+      catchError((err) => {
+        console.error('[AuthorService.getAll]', err);
+        return of([]);
+      }),
+    );
+  }
+
+  getById(id: string): Observable<Author | null> {
+    return from(getDoc(doc(this.firestore, 'authors', id))).pipe(
+      map((snap) => {
+        if (!snap.exists()) return null;
+        return normalizeAuthor({ id: snap.id, ...snap.data() });
+      }),
+      catchError((err) => {
+        console.error('[AuthorService.getById]', err);
+        return of(null);
+      }),
+    );
+  }
+
+  create(data: Omit<Author, 'id' | 'createdAt' | 'updatedAt'>): Observable<Author> {
+    const nowMs = Date.now();
+    const nowTs = Timestamp.fromMillis(nowMs);
+    const newId = doc(collection(this.firestore, 'authors')).id;
+    const author: Author = { ...data, id: newId, createdAt: nowMs, updatedAt: nowMs };
+    const firestorePayload = { ...author, createdAt: nowTs, updatedAt: nowTs };
+    return from(setDoc(doc(this.firestore, 'authors', newId), firestorePayload)).pipe(
+      map(() => author),
+      catchError((err) => {
+        console.error('[AuthorService.create]', err);
+        throw err;
+      }),
+    );
+  }
+
+  update(id: string, data: Partial<Omit<Author, 'id' | 'createdAt'>>): Observable<void> {
+    const nowTs = Timestamp.fromMillis(Date.now());
+    return from(
+      updateDoc(doc(this.firestore, 'authors', id), { ...data, updatedAt: nowTs }),
+    ).pipe(
+      catchError((err) => {
+        console.error('[AuthorService.update]', err);
+        throw err;
+      }),
+    );
+  }
+
+  delete(id: string): Observable<void> {
+    return from(deleteDoc(doc(this.firestore, 'authors', id))).pipe(
+      catchError((err) => {
+        console.error('[AuthorService.delete]', err);
+        throw err;
+      }),
+    );
+  }
+}