ddys-nextjs 0.1.0

package/src/components/request-form.tsx

@@ -0,0 +1,50 @@
+'use client';
+
+import { useState, type FormEvent } from 'react';
+
+export interface DdysRequestFormProps {
+  action?: string;
+  token?: string;
+  honeypotField?: string;
+}
+
+export function DdysRequestForm({ action = '/api/ddys/request', token = '', honeypotField = 'ddys_website' }: DdysRequestFormProps) {
+  const [status, setStatus] = useState('');
+  const [error, setError] = useState(false);
+
+  async function submit(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    const form = event.currentTarget;
+    setStatus('Submitting...');
+    setError(false);
+    const response = await fetch(action, {
+      method: 'POST',
+      body: new FormData(form),
+      credentials: 'same-origin',
+      headers: { 'X-Requested-With': 'XMLHttpRequest' }
+    });
+    const json = await response.json().catch(() => ({ success: false, message: 'Invalid JSON response.' }));
+    if (json.success) {
+      setStatus('Request submitted.');
+      form.reset();
+    } else {
+      setError(true);
+      setStatus(json.message || `Request failed with HTTP ${response.status}.`);
+    }
+  }
+
+  return (
+    <form className="ddys-next-request-form" onSubmit={submit}>
+      <input type="hidden" name="ddys_token" value={token} />
+      <label className="ddys-next-honeypot">Website<input type="text" name={honeypotField} tabIndex={-1} autoComplete="off" /></label>
+      <label>Title<input type="text" name="title" maxLength={255} required /></label>
+      <label>Year<input type="number" name="year" min={1900} max={2099} /></label>
+      <label>Type<select name="type"><option value=""></option><option value="movie">Movie</option><option value="series">Series</option><option value="variety">Variety</option><option value="anime">Anime</option></select></label>
+      <label>Douban ID<input type="text" name="douban_id" maxLength={30} /></label>
+      <label>IMDb ID<input type="text" name="imdb_id" maxLength={30} /></label>
+      <label>Description<textarea name="description" maxLength={1000} /></label>
+      <button type="submit">Submit request</button>
+      <p className={`ddys-next-status${error ? ' is-error' : ''}`} role="status">{status}</p>
+    </form>
+  );
+}

package/src/components/search.tsx

@@ -0,0 +1,41 @@
+'use client';
+
+import { useState, type FormEvent } from 'react';
+import type { DdysItem } from '../types/ddys';
+import { DdysGrid } from './grid';
+
+export interface DdysSearchProps {
+  endpoint?: string;
+}
+
+export function DdysSearch({ endpoint = '/api/ddys/search' }: DdysSearchProps) {
+  const [items, setItems] = useState<DdysItem[]>([]);
+  const [status, setStatus] = useState('');
+
+  async function submit(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    const form = event.currentTarget;
+    const params = new URLSearchParams();
+    for (const [key, value] of new FormData(form).entries()) {
+      if (typeof value === 'string') params.set(key, value);
+    }
+    setStatus('Searching...');
+    const response = await fetch(`${endpoint}?${params.toString()}`, { credentials: 'same-origin' });
+    const json = await response.json().catch(() => ({ data: [] }));
+    const data = Array.isArray(json.data) ? json.data : Array.isArray(json.data?.data) ? json.data.data : [];
+    setItems(data);
+    setStatus(data.length ? '' : 'No DDYS content found.');
+  }
+
+  return (
+    <div className="ddys-next-search-block">
+      <form className="ddys-next-search" onSubmit={submit}>
+        <input type="search" name="q" placeholder="Search DDYS" required />
+        <select name="type" defaultValue="movie"><option value="movie">Movie</option><option value="share">Share</option><option value="request">Request</option></select>
+        <button type="submit">Search</button>
+      </form>
+      {status ? <p className="ddys-next-status" role="status">{status}</p> : null}
+      {items.length ? <DdysGrid items={items} /> : null}
+    </div>
+  );
+}

package/src/components/sources.tsx

@@ -0,0 +1,27 @@
+import type { DdysResource } from '../types/ddys';
+import { resourceParts } from './utils';
+
+export interface DdysSourcesProps {
+  groups: Record<string, DdysResource[]>;
+  allowedProtocols?: string[];
+}
+
+export function DdysSources({ groups, allowedProtocols = ['http:', 'https:', 'magnet:', 'ed2k:', 'thunder:'] }: DdysSourcesProps) {
+  return (
+    <div className="ddys-next-sources">
+      {Object.entries(groups).map(([name, resources]) => (
+        <section className="ddys-next-source-group" key={name}>
+          <h3>{name}</h3>
+          {resources.map((resource, index) => {
+            const links = resourceParts(resource, allowedProtocols);
+            return (
+              <p className="ddys-next-resource" key={index}>
+                {links.length ? links.map((link) => <a href={link.href} target="_blank" rel="noopener noreferrer" key={link.href}>{link.label}</a>) : 'Resource'}
+              </p>
+            );
+          })}
+        </section>
+      ))}
+    </div>
+  );
+}

package/src/components/utils.ts

@@ -0,0 +1,50 @@
+import type { DdysItem, DdysResource } from '../types/ddys';
+import { isAllowedResourceUrl, safeMediaUrl } from '../utils/security';
+
+export function itemTitle(item: DdysItem): string {
+  return String(item.title || item.name || item.cn_name || item.en_name || item.username || item.search_keyword || 'Untitled');
+}
+
+export function itemPoster(item: DdysItem): string {
+  return safeMediaUrl(item.poster || item.cover || item.image || item.avatar);
+}
+
+export function itemSummary(item: DdysItem): string {
+  return String(item.description || item.intro || item.summary || item.note || item.content || item.bio || '').replace(/<[^>]*>/g, '').slice(0, 160);
+}
+
+export function itemUrl(item: DdysItem, siteBaseUrl = 'https://ddys.io'): string {
+  const url = String(item.url || item.link || item.href || '');
+  if (/^https?:\/\//i.test(url)) return url;
+  if (url.startsWith('/')) return `${siteBaseUrl.replace(/\/+$/, '')}${url}`;
+  if (item.slug) return `${siteBaseUrl.replace(/\/+$/, '')}/movie/${encodeURIComponent(item.slug)}`;
+  return '';
+}
+
+export function itemMeta(item: DdysItem): string[] {
+  const meta: string[] = [];
+  for (const key of ['year', 'type', 'type_code', 'region', 'quality', 'episode', 'status', 'resource_type'] as const) {
+    const value = item[key];
+    if (Array.isArray(value)) meta.push(value.join(', '));
+    else if (value !== undefined && value !== null && value !== '') meta.push(String(value));
+  }
+  if (item.rating) meta.push(`Rating ${item.rating}`);
+  return meta;
+}
+
+export function resourceParts(resource: DdysResource, protocols: readonly string[]) {
+  const title = String(resource.title || resource.name || resource.label || resource.download_type || resource.type || resource.quality || 'Resource');
+  const raw = String(resource.url || resource.link || resource.href || '');
+  return raw.split('#').flatMap((part, index, all) => {
+    part = part.trim();
+    if (!part) return [];
+    let label = all.length > 1 ? `${title} ${index + 1}` : title;
+    let href = part;
+    if (part.includes('$')) {
+      const pieces = part.split('$');
+      label = pieces[0] || title;
+      href = pieces.slice(1).join('$');
+    }
+    return isAllowedResourceUrl(href, protocols) ? [{ label, href }] : [];
+  });
+}

package/src/components/view.tsx

@@ -0,0 +1,50 @@
+import type { DdysDisplayOptions, DdysItem } from '../types/ddys';
+import { createDdysServerClient } from '../server/client';
+import { nextFetchOptions } from '../server/cache';
+import type { DdysConfigInput } from '../client/config';
+import { DdysGrid } from './grid';
+import { DdysMovieDetail } from './movie-detail';
+
+export interface DdysViewProps {
+  view: string;
+  params?: Record<string, string | number | undefined>;
+  display?: DdysDisplayOptions;
+  config?: DdysConfigInput;
+}
+
+export async function DdysView({ view, params = {}, display, config }: DdysViewProps) {
+  const client = createDdysServerClient(config);
+  switch (view) {
+    case 'latest': return <DdysGrid items={await asItems(client.latest(params, nextFetchOptions('/latest', client.config)))} display={display} siteBaseUrl={client.config.siteBaseUrl} />;
+    case 'hot': return <DdysGrid items={await asItems(client.hot(params, nextFetchOptions('/hot', client.config)))} display={display} siteBaseUrl={client.config.siteBaseUrl} />;
+    case 'movies': return <DdysGrid items={(await client.movies(params, nextFetchOptions('/movies', client.config))).data as DdysItem[]} display={display} siteBaseUrl={client.config.siteBaseUrl} />;
+    case 'search': return <DdysGrid items={(await client.search(params, nextFetchOptions('/search', client.config))).data as DdysItem[]} display={display} siteBaseUrl={client.config.siteBaseUrl} />;
+    case 'collections': return <DdysGrid items={(await client.collections(params, nextFetchOptions('/collections', client.config))).data as DdysItem[]} display={display} siteBaseUrl={client.config.siteBaseUrl} />;
+    case 'shares': return <DdysGrid items={(await client.shares(params, nextFetchOptions('/shares', client.config))).data as DdysItem[]} display={display} siteBaseUrl={client.config.siteBaseUrl} />;
+    case 'requests': return <DdysGrid items={(await client.requests(params, nextFetchOptions('/requests', client.config))).data as DdysItem[]} display={display} siteBaseUrl={client.config.siteBaseUrl} />;
+    case 'activities': return <DdysGrid items={(await client.activities(params, nextFetchOptions('/activities', client.config))).data as DdysItem[]} display={display} siteBaseUrl={client.config.siteBaseUrl} />;
+    case 'movie': return <DdysMovieDetail movie={await client.movie(String(params.slug || ''), nextFetchOptions(`/movies/${params.slug}`, client.config)) as DdysItem} display={display} siteBaseUrl={client.config.siteBaseUrl} />;
+    case 'types': return <DdysGrid items={dictionary(await client.types(nextFetchOptions('/types', client.config)))} display={display} siteBaseUrl={client.config.siteBaseUrl} />;
+    case 'genres': return <DdysGrid items={dictionary(await client.genres(nextFetchOptions('/genres', client.config)))} display={display} siteBaseUrl={client.config.siteBaseUrl} />;
+    case 'regions': return <DdysGrid items={dictionary(await client.regions(nextFetchOptions('/regions', client.config)))} display={display} siteBaseUrl={client.config.siteBaseUrl} />;
+    default: return <div className="ddys-next-empty">Unsupported DDYS view.</div>;
+  }
+}
+
+async function asItems(payload: Promise<unknown>): Promise<DdysItem[]> {
+  const data = await payload;
+  if (Array.isArray(data)) return data as DdysItem[];
+  if (data && typeof data === 'object' && Array.isArray((data as { data?: unknown }).data)) return (data as { data: DdysItem[] }).data;
+  return [];
+}
+
+function dictionary(payload: unknown): DdysItem[] {
+  if (Array.isArray(payload)) return payload.map((item) => typeof item === 'object' ? item as DdysItem : { title: String(item) });
+  if (payload && typeof payload === 'object') {
+    return Object.entries(payload as Record<string, unknown>).map(([code, value]) => {
+      if (value && typeof value === 'object') return { code, ...(value as Record<string, unknown>) } as DdysItem;
+      return { title: String(value), code } as DdysItem;
+    });
+  }
+  return [];
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './client/index';
+export type * from './types/ddys';

package/src/metadata/index.ts

@@ -0,0 +1,273 @@
+import 'server-only';
+
+import type { Metadata, MetadataRoute } from 'next';
+import type { DdysConfig, DdysConfigInput } from '../client/config';
+import type { DdysItem } from '../types/ddys';
+import { createDdysServerClient } from '../server/client';
+import { nextFetchOptions } from '../server/cache';
+import { getDdysConfigFromEnv } from '../server/config';
+import { itemPoster, itemSummary, itemTitle, itemUrl } from '../components/utils';
+
+type SitemapEntry = MetadataRoute.Sitemap[number];
+type SitemapChangeFrequency = NonNullable<SitemapEntry['changeFrequency']>;
+
+export interface DdysMetadataOptions {
+  config?: DdysConfigInput;
+  title?: string;
+  description?: string;
+  path?: string;
+  siteName?: string;
+  titleTemplate?: string;
+  images?: string[];
+  robots?: Metadata['robots'];
+}
+
+export interface DdysMovieMetadataOptions extends DdysMetadataOptions {
+  fallbackTitle?: string;
+  fallbackDescription?: string;
+  fallbackImage?: string;
+  throwOnError?: boolean;
+}
+
+export interface DdysSitemapOptions {
+  config?: DdysConfigInput;
+  basePath?: string;
+  staticPaths?: string[];
+  includeLatest?: boolean;
+  latestLimit?: number;
+  changeFrequency?: SitemapChangeFrequency;
+  priority?: number;
+  moviePriority?: number;
+  throwOnError?: boolean;
+}
+
+export interface DdysRobotsOptions {
+  config?: DdysConfigInput;
+  userAgent?: string | string[];
+  allow?: string | string[];
+  disallow?: string | string[];
+  sitemap?: string | string[];
+  host?: string;
+}
+
+export interface DdysManifestOptions {
+  config?: DdysConfigInput;
+  name?: string;
+  shortName?: string;
+  description?: string;
+  startUrl?: string;
+  scope?: string;
+  display?: MetadataRoute.Manifest['display'];
+  themeColor?: string;
+  backgroundColor?: string;
+  iconBasePath?: string;
+  icons?: MetadataRoute.Manifest['icons'];
+}
+
+export function createDdysMetadata(options: DdysMetadataOptions = {}): Metadata {
+  return metadataFromConfig(getDdysConfigFromEnv(options.config), options);
+}
+
+export async function createDdysMovieMetadata(slug: string, options: DdysMovieMetadataOptions = {}): Promise<Metadata> {
+  const client = createDdysServerClient(options.config);
+  const encodedSlug = encodeURIComponent(String(slug));
+  const path = options.path ?? `/ddys/movie/${encodedSlug}`;
+  try {
+    const movie = await client.movie(slug, nextFetchOptions(`/movies/${encodedSlug}`, client.config)) as DdysItem;
+    const title = itemTitle(movie);
+    const description = itemSummary(movie) || options.description || `${title} - DDYS`;
+    const poster = itemPoster(movie) || options.fallbackImage;
+    const url = options.path || itemUrl(movie, client.config.siteBaseUrl) || path;
+    return metadataFromConfig(client.config, {
+      ...options,
+      title,
+      description,
+      path: url,
+      images: poster ? [poster, ...(options.images ?? [])] : options.images
+    });
+  } catch (error) {
+    if (options.throwOnError) throw error;
+    return metadataFromConfig(client.config, {
+      ...options,
+      title: options.fallbackTitle ?? options.title ?? 'DDYS Movie',
+      description: options.fallbackDescription ?? options.description ?? 'DDYS movie details.',
+      path,
+      images: options.fallbackImage ? [options.fallbackImage, ...(options.images ?? [])] : options.images
+    });
+  }
+}
+
+export async function createDdysSitemap(options: DdysSitemapOptions = {}): Promise<MetadataRoute.Sitemap> {
+  const client = createDdysServerClient(options.config);
+  const config = client.config;
+  const basePath = normalizePath(options.basePath ?? '/ddys');
+  const now = new Date();
+  const staticPaths = options.staticPaths ?? [
+    basePath,
+    joinPath(basePath, 'latest'),
+    joinPath(basePath, 'hot'),
+    joinPath(basePath, 'movies'),
+    joinPath(basePath, 'search'),
+    joinPath(basePath, 'calendar'),
+    joinPath(basePath, 'collections'),
+    joinPath(basePath, 'shares'),
+    joinPath(basePath, 'request')
+  ];
+  const entries: MetadataRoute.Sitemap = staticPaths.flatMap((path) => sitemapEntry(config.siteBaseUrl, path, now, options.changeFrequency ?? 'hourly', options.priority ?? 0.7));
+
+  if (options.includeLatest !== false) {
+    try {
+      const latest = await client.latest({ limit: options.latestLimit ?? 24 }, nextFetchOptions('/latest', config));
+      for (const item of asItems(latest)) {
+        if (!item.slug) continue;
+        entries.push(...sitemapEntry(config.siteBaseUrl, joinPath(basePath, `movie/${encodeURIComponent(item.slug)}`), now, 'daily', options.moviePriority ?? 0.8));
+      }
+    } catch (error) {
+      if (options.throwOnError) throw error;
+    }
+  }
+
+  return dedupeSitemap(entries);
+}
+
+export function createDdysRobots(options: DdysRobotsOptions = {}): MetadataRoute.Robots {
+  const config = getDdysConfigFromEnv(options.config);
+  return {
+    rules: {
+      userAgent: options.userAgent ?? '*',
+      allow: options.allow ?? '/',
+      disallow: options.disallow ?? ['/api/ddys/diagnostics', '/api/ddys/revalidate']
+    },
+    sitemap: options.sitemap ?? absoluteUrl(config.siteBaseUrl, '/sitemap.xml'),
+    host: options.host ?? config.siteBaseUrl
+  };
+}
+
+export function createDdysManifest(options: DdysManifestOptions = {}): MetadataRoute.Manifest {
+  const config = getDdysConfigFromEnv(options.config);
+  const iconBasePath = normalizePath(options.iconBasePath ?? '/images');
+  return {
+    name: options.name ?? 'DDYS',
+    short_name: options.shortName ?? 'DDYS',
+    description: options.description ?? 'DDYS API powered movie and video experience.',
+    start_url: options.startUrl ?? '/ddys',
+    scope: options.scope ?? '/',
+    display: options.display ?? 'standalone',
+    background_color: options.backgroundColor ?? '#0f172a',
+    theme_color: options.themeColor ?? '#0f172a',
+    icons: options.icons ?? [
+      { src: joinPath(iconBasePath, 'icon-192.png'), sizes: '192x192', type: 'image/png' },
+      { src: joinPath(iconBasePath, 'icon-512.png'), sizes: '512x512', type: 'image/png' }
+    ]
+  };
+}
+
+export function createDdysMovieJsonLd(movie: DdysItem, configInput: DdysConfigInput = {}) {
+  const config = getDdysConfigFromEnv(configInput);
+  const image = itemPoster(movie);
+  const url = itemUrl(movie, config.siteBaseUrl);
+  return stripEmpty({
+    '@context': 'https://schema.org',
+    '@type': 'Movie',
+    name: itemTitle(movie),
+    description: itemSummary(movie),
+    image,
+    url,
+    datePublished: movie.year ? String(movie.year) : undefined,
+    genre: Array.isArray(movie.genre) ? movie.genre.join(', ') : movie.genre,
+    countryOfOrigin: Array.isArray(movie.region) ? movie.region.join(', ') : movie.region,
+    aggregateRating: movie.rating ? {
+      '@type': 'AggregateRating',
+      ratingValue: String(movie.rating),
+      bestRating: '10'
+    } : undefined
+  });
+}
+
+function metadataFromConfig(config: DdysConfig, options: DdysMetadataOptions): Metadata {
+  const siteName = options.siteName ?? 'DDYS';
+  const title = options.title ?? siteName;
+  const description = options.description ?? 'DDYS API powered movie and video experience.';
+  const canonical = absoluteUrl(config.siteBaseUrl, options.path ?? '/ddys');
+  const images = normalizeImages(config.siteBaseUrl, options.images);
+  return {
+    metadataBase: new URL(config.siteBaseUrl),
+    title: {
+      default: title,
+      template: options.titleTemplate ?? `%s | ${siteName}`
+    },
+    applicationName: siteName,
+    description,
+    alternates: canonical ? { canonical } : undefined,
+    openGraph: {
+      title,
+      description,
+      url: canonical,
+      siteName,
+      type: 'website',
+      images
+    },
+    twitter: {
+      card: images.length ? 'summary_large_image' : 'summary',
+      title,
+      description,
+      images
+    },
+    robots: options.robots ?? {
+      index: true,
+      follow: true
+    }
+  };
+}
+
+function normalizeImages(baseUrl: string, images: string[] = []) {
+  return images.flatMap((image) => {
+    const url = absoluteUrl(baseUrl, image);
+    return url ? [url] : [];
+  });
+}
+
+function sitemapEntry(baseUrl: string, path: string, lastModified: Date, changeFrequency: SitemapChangeFrequency, priority: number): MetadataRoute.Sitemap {
+  const url = absoluteUrl(baseUrl, path);
+  return url ? [{ url, lastModified, changeFrequency, priority }] : [];
+}
+
+function dedupeSitemap(entries: MetadataRoute.Sitemap): MetadataRoute.Sitemap {
+  const seen = new Set<string>();
+  return entries.filter((entry) => {
+    if (seen.has(entry.url)) return false;
+    seen.add(entry.url);
+    return true;
+  });
+}
+
+function asItems(payload: unknown): DdysItem[] {
+  if (Array.isArray(payload)) return payload as DdysItem[];
+  if (payload && typeof payload === 'object' && Array.isArray((payload as { data?: unknown }).data)) return (payload as { data: DdysItem[] }).data;
+  return [];
+}
+
+function absoluteUrl(baseUrl: string, value: string): string | undefined {
+  const text = String(value || '').trim();
+  if (!text) return undefined;
+  try {
+    return new URL(text, baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`).toString();
+  } catch {
+    return undefined;
+  }
+}
+
+function normalizePath(path: string): string {
+  const clean = String(path || '/').trim();
+  return clean.startsWith('/') ? clean.replace(/\/+$/, '') || '/' : `/${clean.replace(/\/+$/, '')}`;
+}
+
+function joinPath(basePath: string, segment: string): string {
+  const base = normalizePath(basePath);
+  const cleanSegment = String(segment || '').replace(/^\/+/, '').replace(/\/+$/, '');
+  return cleanSegment ? `${base === '/' ? '' : base}/${cleanSegment}` : base;
+}
+
+function stripEmpty(input: Record<string, unknown>) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== null && value !== ''));
+}

package/src/route-handlers/diagnostics.ts

@@ -0,0 +1,61 @@
+import { DDYS_VERSION, type DdysConfigInput } from '../client/config';
+import { DdysError } from '../client/error';
+import { createDdysServerClient } from '../server/client';
+import { getDdysConfigFromEnv, safeDdysConfig } from '../server/config';
+
+export interface DdysDiagnosticsRouteOptions {
+  config?: DdysConfigInput;
+}
+
+export function createDdysDiagnosticsRouteHandler(options: DdysDiagnosticsRouteOptions = {}) {
+  return async function GET() {
+    const config = getDdysConfigFromEnv(options.config);
+    if (!config.diagnostics.enabled) {
+      return Response.json({ success: false, message: 'DDYS diagnostics is disabled.' }, { status: 403 });
+    }
+    return Response.json({
+      success: true,
+      data: {
+        version: DDYS_VERSION,
+        runtime: typeof EdgeRuntime === 'string' ? 'edge' : 'node',
+        next: 'app-router',
+        config: safeDdysConfig(config),
+        views: [
+          'movies', 'latest', 'hot', 'search', 'suggest', 'calendar',
+          'movie', 'sources', 'related', 'comments',
+          'collections', 'collection', 'shares', 'share',
+          'requests', 'activities', 'user', 'types', 'genres', 'regions'
+        ],
+        routeHandlers: [
+          '/api/ddys/[route]',
+          '/api/ddys/request',
+          '/api/ddys/diagnostics',
+          '/api/ddys/revalidate'
+        ]
+      }
+    });
+  };
+}
+
+export function createDdysDiagnosticsTestRouteHandler(options: DdysDiagnosticsRouteOptions = {}) {
+  return async function POST() {
+    const config = getDdysConfigFromEnv(options.config);
+    if (!config.diagnostics.enabled) {
+      return Response.json({ success: false, message: 'DDYS diagnostics is disabled.' }, { status: 403 });
+    }
+    try {
+      const payload = await createDdysServerClient(options.config).get('/latest', { limit: 1 }, { noCache: true });
+      return Response.json({ success: true, data: payload });
+    } catch (error) {
+      return Response.json({
+        success: false,
+        message: error instanceof DdysError ? error.message : 'DDYS diagnostics test failed.'
+      }, { status: 500 });
+    }
+  };
+}
+
+declare const EdgeRuntime: string | undefined;
+
+export const ddysDiagnosticsGET = createDdysDiagnosticsRouteHandler();
+export const ddysDiagnosticsTestPOST = createDdysDiagnosticsTestRouteHandler();

package/src/route-handlers/index.ts

@@ -0,0 +1,10 @@
+export { createDdysProxyRouteHandler, ddysProxyGET, type DdysProxyRouteOptions } from './proxy';
+export { createDdysRequestRouteHandler, ddysRequestPOST, type DdysRequestRouteOptions } from './request';
+export {
+  createDdysDiagnosticsRouteHandler,
+  createDdysDiagnosticsTestRouteHandler,
+  ddysDiagnosticsGET,
+  ddysDiagnosticsTestPOST,
+  type DdysDiagnosticsRouteOptions
+} from './diagnostics';
+export { createDdysRevalidateRouteHandler, ddysRevalidatePOST, type DdysRevalidateRouteOptions } from './revalidate';

package/src/route-handlers/proxy.ts

@@ -0,0 +1,42 @@
+import { DdysError } from '../client/error';
+import type { DdysConfigInput } from '../client/config';
+import type { DdysRouteHandlerContext } from '../types/ddys';
+import { createDdysServerClient } from '../server/client';
+
+export interface DdysProxyRouteOptions {
+  config?: DdysConfigInput;
+}
+
+export function createDdysProxyRouteHandler(options: DdysProxyRouteOptions = {}) {
+  return async function GET(request: Request, context: DdysRouteHandlerContext = {}) {
+    const params = await context.params;
+    const route = params?.route ?? new URL(request.url).searchParams.get('route') ?? '';
+    const query = Object.fromEntries(new URL(request.url).searchParams.entries());
+    try {
+      const client = createDdysServerClient(options.config);
+      if (!client.config.proxy.enabled) return json({ success: false, message: 'DDYS proxy is disabled.' }, 404);
+      const payload = await client.proxy(route, query);
+      return json(payload);
+    } catch (error) {
+      return errorJson(error);
+    }
+  };
+}
+
+export const ddysProxyGET = createDdysProxyRouteHandler();
+
+function json(payload: unknown, status = 200) {
+  return Response.json(payload, {
+    status,
+    headers: {
+      'Cache-Control': 'private, no-store'
+    }
+  });
+}
+
+function errorJson(error: unknown) {
+  if (error instanceof DdysError) {
+    return json({ success: false, message: error.message, status: error.status }, error.status >= 400 ? error.status : 500);
+  }
+  return json({ success: false, message: error instanceof Error ? error.message : 'DDYS proxy failed.' }, 500);
+}

package/src/route-handlers/request.ts

@@ -0,0 +1,46 @@
+import type { DdysConfigInput } from '../client/config';
+import { getDdysConfigFromEnv } from '../server/config';
+import { submitDdysRequest } from '../server/request-service';
+import { formDataToObject } from '../utils/security';
+
+export interface DdysRequestRouteOptions {
+  config?: DdysConfigInput;
+  identity?: (request: Request) => string;
+}
+
+export function createDdysRequestRouteHandler(options: DdysRequestRouteOptions = {}) {
+  return async function POST(request: Request) {
+    const config = getDdysConfigFromEnv(options.config);
+    const formData = await request.formData();
+    const input = formDataToObject(formData);
+    const identity = options.identity?.(request) ?? identityFromRequest(request);
+    try {
+      const payload = await submitDdysRequest(input, config, {
+        identity,
+        token: input.ddys_token
+      });
+      return Response.json({ success: true, data: payload });
+    } catch (error) {
+      return Response.json({
+        success: false,
+        message: error instanceof Error ? error.message : 'DDYS request submission failed.'
+      }, { status: statusFor(error) });
+    }
+  };
+}
+
+export const ddysRequestPOST = createDdysRequestRouteHandler();
+
+function identityFromRequest(request: Request): string {
+  const forwarded = request.headers.get('x-forwarded-for')?.split(',')[0]?.trim();
+  const realIp = request.headers.get('x-real-ip');
+  return forwarded || realIp || 'anonymous';
+}
+
+function statusFor(error: unknown): number {
+  if (!(error instanceof Error)) return 500;
+  if (/disabled/i.test(error.message)) return 403;
+  if (/token|submission|invalid/i.test(error.message)) return 400;
+  if (/too many/i.test(error.message)) return 429;
+  return 500;
+}