ddys-nextjs 0.1.0

package/src/route-handlers/revalidate.ts

@@ -0,0 +1,31 @@
+import type { DdysConfigInput } from '../client/config';
+import { getDdysConfigFromEnv } from '../server/config';
+import { revalidateDdys } from '../server/cache';
+
+export interface DdysRevalidateRouteOptions {
+  config?: DdysConfigInput;
+  token?: string;
+}
+
+export function createDdysRevalidateRouteHandler(options: DdysRevalidateRouteOptions = {}) {
+  return async function POST(request: Request) {
+    const expected = options.token ?? process.env.DDYS_REVALIDATE_TOKEN ?? '';
+    const given = request.headers.get('x-ddys-revalidate-token') ?? new URL(request.url).searchParams.get('token') ?? '';
+    if (!expected || given !== expected) {
+      return Response.json({ success: false, message: 'Invalid revalidation token.' }, { status: 403 });
+    }
+    getDdysConfigFromEnv(options.config);
+    const body = await request.json().catch(() => ({}));
+    const tag = typeof body.tag === 'string' ? body.tag : undefined;
+    const tagProfile = typeof body.tagProfile === 'string' ? body.tagProfile : undefined;
+    const path = typeof body.path === 'string' ? body.path : undefined;
+    const pathType = body.pathType === 'layout' ? 'layout' : 'page';
+    if (!tag && !path) {
+      return Response.json({ success: false, message: 'Missing tag or path.' }, { status: 422 });
+    }
+    revalidateDdys({ tag, tagProfile, path, pathType });
+    return Response.json({ success: true, data: { tag, tagProfile, path, pathType } });
+  };
+}
+
+export const ddysRevalidatePOST = createDdysRevalidateRouteHandler();

package/src/server/cache.ts

@@ -0,0 +1,45 @@
+import 'server-only';
+
+import { revalidatePath, revalidateTag } from 'next/cache';
+import type { DdysConfig } from '../client/config';
+
+export interface DdysRevalidateInput {
+  tag?: string;
+  tagProfile?: string | { expire?: number };
+  path?: string;
+  pathType?: 'layout' | 'page';
+}
+
+export function ttlForPath(path: string, config: DdysConfig): number {
+  if (/^\/(types|genres|regions|calendar)$/.test(path)) return config.cache.dictionaryTtl;
+  if (/^\/(latest|hot)$/.test(path)) return config.cache.freshTtl;
+  if (/^\/(movies\/[^/]+|movies\/[^/]+\/sources|movies\/[^/]+\/related|collections\/[^/]+|shares\/[0-9]+)$/.test(path)) return config.cache.detailTtl;
+  if (/^\/(movies\/[^/]+\/comments|suggest|shares|requests|activities|user\/)/.test(path)) return config.cache.communityTtl;
+  if (/^\/(movies|search|collections)/.test(path)) return config.cache.listTtl;
+  return config.cache.defaultTtl;
+}
+
+export function tagsForPath(path: string): string[] {
+  const tags = ['ddys'];
+  if (/^\/latest/.test(path)) tags.push('ddys:latest');
+  if (/^\/hot/.test(path)) tags.push('ddys:hot');
+  if (/^\/movies$/.test(path)) tags.push('ddys:movies');
+  if (/^\/movies\/([^/]+)/.test(path)) tags.push(`ddys:movie:${path.split('/')[2]}`);
+  if (/^\/(types|genres|regions|calendar)$/.test(path)) tags.push('ddys:dictionary');
+  if (/^\/(shares|requests|activities|user\/|movies\/[^/]+\/comments)/.test(path)) tags.push('ddys:community');
+  return tags;
+}
+
+export function nextFetchOptions(path: string, config: DdysConfig) {
+  return {
+    next: {
+      revalidate: ttlForPath(path, config),
+      tags: tagsForPath(path)
+    }
+  };
+}
+
+export function revalidateDdys(input: DdysRevalidateInput) {
+  if (input.tag) revalidateTag(input.tag, input.tagProfile ?? 'max');
+  if (input.path) revalidatePath(input.path, input.pathType ?? 'page');
+}

package/src/server/client.ts

@@ -0,0 +1,15 @@
+import 'server-only';
+
+import { DdysClient } from '../client/client';
+import type { DdysConfigInput } from '../client/config';
+import { getDdysConfigFromEnv } from './config';
+import { nextFetchOptions } from './cache';
+
+export function createDdysServerClient(config: DdysConfigInput = {}) {
+  return new DdysClient(getDdysConfigFromEnv(config));
+}
+
+export function withDdysCache(path: string, config: DdysConfigInput = {}) {
+  const merged = getDdysConfigFromEnv(config);
+  return nextFetchOptions(path, merged);
+}

package/src/server/config.ts

@@ -0,0 +1,49 @@
+import 'server-only';
+
+import { DEFAULT_DDYS_CONFIG, mergeDdysConfig, type DdysConfig, type DdysConfigInput } from '../client/config';
+import { boolValue, intRange, normalizeBaseUrl } from '../utils/security';
+
+export function getDdysConfigFromEnv(input: DdysConfigInput = {}): DdysConfig {
+  const env = process.env;
+  const envConfig: DdysConfigInput = {
+    apiBaseUrl: normalizeBaseUrl(env.DDYS_API_BASE_URL, DEFAULT_DDYS_CONFIG.apiBaseUrl),
+    siteBaseUrl: normalizeBaseUrl(env.DDYS_SITE_BASE_URL, DEFAULT_DDYS_CONFIG.siteBaseUrl),
+    apiKey: env.DDYS_API_KEY ?? '',
+    timeout: intRange(env.DDYS_TIMEOUT, DEFAULT_DDYS_CONFIG.timeout, 1, 60),
+    retryTimes: intRange(env.DDYS_RETRY_TIMES, DEFAULT_DDYS_CONFIG.retryTimes, 0, 5),
+    retrySleep: intRange(env.DDYS_RETRY_SLEEP, DEFAULT_DDYS_CONFIG.retrySleep, 0, 3000),
+    requestForm: {
+      enabled: boolValue(env.DDYS_REQUEST_FORM_ENABLED),
+      secret: env.DDYS_FORM_SECRET,
+      csrf: env.DDYS_REQUEST_FORM_CSRF === undefined ? true : boolValue(env.DDYS_REQUEST_FORM_CSRF)
+    },
+    diagnostics: {
+      enabled: boolValue(env.DDYS_DIAGNOSTICS_ENABLED)
+    }
+  };
+
+  return mergeDdysConfig({
+    ...envConfig,
+    ...input,
+    cache: { ...envConfig.cache, ...input.cache },
+    proxy: { ...envConfig.proxy, ...input.proxy },
+    requestForm: { ...envConfig.requestForm, ...input.requestForm },
+    diagnostics: { ...envConfig.diagnostics, ...input.diagnostics },
+    security: { ...envConfig.security, ...input.security }
+  });
+}
+
+export function requireDdysApiKey(config: DdysConfig): void {
+  if (!config.apiKey) throw new Error('DDYS_API_KEY is required for this server action.');
+}
+
+export function safeDdysConfig(config: DdysConfig) {
+  return {
+    ...config,
+    apiKey: config.apiKey ? 'configured' : 'not configured',
+    requestForm: {
+      ...config.requestForm,
+      secret: config.requestForm.secret ? 'configured' : 'not configured'
+    }
+  };
+}

package/src/server/index.ts

@@ -0,0 +1,11 @@
+export { createDdysServerClient, withDdysCache } from './client';
+export { getDdysConfigFromEnv, requireDdysApiKey, safeDdysConfig } from './config';
+export { nextFetchOptions, revalidateDdys, tagsForPath, ttlForPath } from './cache';
+export {
+  createRequestFormToken,
+  enforceRateLimit,
+  normalizeRequestInput,
+  submitDdysRequest,
+  verifyRequestFormToken,
+  type DdysRequestSubmitOptions
+} from './request-service';

package/src/server/request-service.ts

@@ -0,0 +1,105 @@
+import 'server-only';
+
+import type { DdysConfig } from '../client/config';
+import { DdysClient } from '../client/client';
+import type { DdysRequestInput } from '../types/ddys';
+import { scalar } from '../utils/security';
+
+const globalStore = globalThis as typeof globalThis & {
+  __ddysNextRateLimit?: Map<string, number>;
+};
+
+export interface DdysRequestSubmitOptions {
+  identity: string;
+  token?: string;
+}
+
+export async function submitDdysRequest(input: Record<string, unknown>, config: DdysConfig, options: DdysRequestSubmitOptions) {
+  if (!config.requestForm.enabled) throw new Error('DDYS request form is disabled.');
+  if (config.requestForm.csrf && !(await verifyRequestFormToken(options.token || '', config, options.identity))) {
+    throw new Error('Invalid request token.');
+  }
+  const honeypot = scalar(input[config.requestForm.honeypotField]);
+  if (honeypot !== '') throw new Error('Invalid submission.');
+  enforceRateLimit(options.identity, config.requestForm.rateLimitSeconds);
+  const payload = normalizeRequestInput(input);
+  return new DdysClient(config).createRequest(payload);
+}
+
+export function normalizeRequestInput(input: Record<string, unknown>): DdysRequestInput {
+  const title = scalar(input.title).slice(0, 255);
+  if (!title) throw new Error('Title is required.');
+  const year = scalar(input.year);
+  if (year && (!/^\d{4}$/.test(year) || Number(year) < 1900 || Number(year) > 2099)) throw new Error('Invalid year.');
+  const type = scalar(input.type).toLowerCase();
+  if (type && !['movie', 'series', 'variety', 'anime'].includes(type)) throw new Error('Invalid type.');
+  const douban = scalar(input.douban_id);
+  if (douban && !/^\d{1,20}$/.test(douban)) throw new Error('Invalid Douban ID.');
+  const imdb = scalar(input.imdb_id);
+  if (imdb && !/^tt\d{1,20}$/i.test(imdb)) throw new Error('Invalid IMDb ID.');
+
+  return Object.fromEntries(Object.entries({
+    title,
+    year: year ? Number(year) : undefined,
+    type: type || undefined,
+    description: scalar(input.description).slice(0, 1000) || undefined,
+    douban_id: douban || undefined,
+    imdb_id: imdb || undefined,
+    site: 'Next.js'
+  }).filter(([, value]) => value !== undefined && value !== '')) as DdysRequestInput;
+}
+
+export function enforceRateLimit(identity: string, seconds: number): void {
+  globalStore.__ddysNextRateLimit ??= new Map();
+  const key = `ddys:${identity}`;
+  const now = Date.now();
+  const last = globalStore.__ddysNextRateLimit.get(key) ?? 0;
+  if (now - last < seconds * 1000) throw new Error('Too many submissions. Please try again later.');
+  globalStore.__ddysNextRateLimit.set(key, now);
+}
+
+export async function createRequestFormToken(config: DdysConfig, identity = 'anonymous', now = Date.now()): Promise<string> {
+  const secret = formSecret(config);
+  if (!secret) return '';
+  const bucket = Math.floor(now / (config.requestForm.tokenTtlSeconds * 1000));
+  const signature = await hmac(secret, `ddys-request:${identity}:${bucket}`);
+  return `${bucket}.${signature}`;
+}
+
+export async function verifyRequestFormToken(token: string, config: DdysConfig, identity = 'anonymous', now = Date.now()): Promise<boolean> {
+  const secret = formSecret(config);
+  if (!secret) return false;
+  const [bucketText, signature] = token.split('.', 2);
+  const bucket = Number(bucketText);
+  if (!Number.isInteger(bucket) || !signature) return false;
+  const current = Math.floor(now / (config.requestForm.tokenTtlSeconds * 1000));
+  if (bucket < current - 1 || bucket > current) return false;
+  const expected = await hmac(secret, `ddys-request:${identity}:${bucket}`);
+  return timingSafeEqual(signature, expected);
+}
+
+function formSecret(config: DdysConfig): string {
+  return config.requestForm.secret || config.apiKey || '';
+}
+
+async function hmac(secret: string, value: string): Promise<string> {
+  if (!globalThis.crypto?.subtle) {
+    throw new Error('Web Crypto is required to sign DDYS request form tokens.');
+  }
+  const key = await globalThis.crypto.subtle.importKey(
+    'raw',
+    new TextEncoder().encode(secret),
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign']
+  );
+  const signature = await globalThis.crypto.subtle.sign('HMAC', key, new TextEncoder().encode(value));
+  return Array.from(new Uint8Array(signature)).map((byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+
+function timingSafeEqual(a: string, b: string): boolean {
+  if (a.length !== b.length) return false;
+  let out = 0;
+  for (let i = 0; i < a.length; i++) out |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return out === 0;
+}

package/src/styles/ddys.css

@@ -0,0 +1,228 @@
+.ddys-next {
+  color: #17202a;
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  line-height: 1.55;
+}
+
+.ddys-next-items {
+  display: grid;
+  gap: 16px;
+  grid-template-columns: repeat(var(--ddys-next-columns, 4), minmax(0, 1fr));
+}
+
+.ddys-next-layout-list .ddys-next-items,
+.ddys-next-layout-compact .ddys-next-items {
+  grid-template-columns: 1fr;
+}
+
+.ddys-next-card {
+  background: #fff;
+  border: 1px solid #d6e0e8;
+  border-radius: 8px;
+  display: grid;
+  grid-template-rows: auto 1fr;
+  min-width: 0;
+  overflow: hidden;
+}
+
+.ddys-next-layout-list .ddys-next-card {
+  grid-template-columns: minmax(120px, 180px) minmax(0, 1fr);
+  grid-template-rows: 1fr;
+}
+
+.ddys-next-poster {
+  aspect-ratio: 2 / 3;
+  background: #eef3f6;
+  overflow: hidden;
+}
+
+.ddys-next-poster img {
+  display: block;
+  height: 100%;
+  object-fit: cover;
+  width: 100%;
+}
+
+.ddys-next-card-body {
+  display: grid;
+  gap: 8px;
+  min-width: 0;
+  padding: 12px;
+}
+
+.ddys-next-title {
+  font-size: 16px;
+  line-height: 1.3;
+  margin: 0;
+  overflow-wrap: anywhere;
+}
+
+.ddys-next-title a {
+  color: #0d5e8c;
+  text-decoration: none;
+}
+
+.ddys-next-title a:hover {
+  text-decoration: underline;
+}
+
+.ddys-next-meta,
+.ddys-next-summary,
+.ddys-next-status {
+  color: #586777;
+  font-size: 13px;
+}
+
+.ddys-next-empty,
+.ddys-next-description,
+.ddys-next-source-group,
+.ddys-next-diagnostics {
+  background: #fff;
+  border: 1px solid #d6e0e8;
+  border-radius: 8px;
+  padding: 16px;
+}
+
+.ddys-next-detail,
+.ddys-next-sources,
+.ddys-next-related {
+  display: grid;
+  gap: 16px;
+}
+
+.ddys-next-resource {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.ddys-next-resource a,
+.ddys-next button {
+  border: 1px solid #c9d7e3;
+  border-radius: 8px;
+  color: #17202a;
+  display: inline-flex;
+  font-size: 14px;
+  font-weight: 650;
+  min-height: 38px;
+  padding: 8px 12px;
+  text-decoration: none;
+}
+
+.ddys-next button {
+  background: #17324d;
+  border-color: #17324d;
+  color: #fff;
+  cursor: pointer;
+}
+
+.ddys-next-search,
+.ddys-next-request-form {
+  align-items: end;
+  display: grid;
+  gap: 12px;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+
+.ddys-next-request-form {
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+
+.ddys-next-search input,
+.ddys-next-search select,
+.ddys-next-request-form input,
+.ddys-next-request-form select,
+.ddys-next-request-form textarea {
+  border: 1px solid #b9cad8;
+  border-radius: 8px;
+  box-sizing: border-box;
+  font: inherit;
+  min-height: 40px;
+  padding: 8px 10px;
+  width: 100%;
+}
+
+.ddys-next-request-form label {
+  display: grid;
+  gap: 6px;
+  min-width: 0;
+}
+
+.ddys-next-request-form textarea {
+  min-height: 104px;
+  resize: vertical;
+}
+
+.ddys-next-honeypot {
+  height: 1px;
+  left: -10000px;
+  overflow: hidden;
+  position: absolute;
+  top: auto;
+  width: 1px;
+}
+
+.ddys-next-status {
+  margin: 0;
+  min-height: 22px;
+}
+
+.ddys-next-status.is-error {
+  color: #8f2f16;
+}
+
+.ddys-next-diagnostics {
+  display: grid;
+  gap: 12px;
+}
+
+.ddys-next-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.ddys-next-diagnostics pre {
+  overflow: auto;
+  white-space: pre-wrap;
+}
+
+@media (max-width: 900px) {
+  .ddys-next-items {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
+
+@media (max-width: 640px) {
+  .ddys-next-items,
+  .ddys-next-layout-list .ddys-next-card,
+  .ddys-next-search,
+  .ddys-next-request-form {
+    grid-template-columns: 1fr;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  .ddys-next-theme-auto {
+    color: #ecf2f6;
+  }
+
+  .ddys-next-theme-auto .ddys-next-card,
+  .ddys-next-theme-auto .ddys-next-empty,
+  .ddys-next-theme-auto .ddys-next-description,
+  .ddys-next-theme-auto .ddys-next-source-group,
+  .ddys-next-theme-auto .ddys-next-diagnostics {
+    background: #151f29;
+    border-color: #304253;
+  }
+
+  .ddys-next-theme-auto .ddys-next-meta,
+  .ddys-next-theme-auto .ddys-next-summary,
+  .ddys-next-theme-auto .ddys-next-status {
+    color: #a7b7c3;
+  }
+
+  .ddys-next-theme-auto .ddys-next-title a {
+    color: #83c7e8;
+  }
+}

package/src/types/ddys.ts

@@ -0,0 +1,99 @@
+export type DdysScalar = string | number | boolean | null | undefined;
+
+export interface DdysQuery {
+  [key: string]: DdysScalar | DdysScalar[];
+}
+
+export interface DdysApiResponse<T = unknown> {
+  success?: boolean;
+  message?: string;
+  data?: T;
+  meta?: DdysPaginationMeta;
+  [key: string]: unknown;
+}
+
+export interface DdysPaginationMeta {
+  page?: number;
+  per_page?: number;
+  total?: number;
+  total_pages?: number;
+  [key: string]: unknown;
+}
+
+export interface DdysPaginated<T = DdysItem> {
+  data: T[];
+  meta: DdysPaginationMeta;
+}
+
+export interface DdysItem {
+  id?: string | number;
+  slug?: string;
+  title?: string;
+  name?: string;
+  cn_name?: string;
+  en_name?: string;
+  username?: string;
+  search_keyword?: string;
+  poster?: string;
+  cover?: string;
+  image?: string;
+  avatar?: string;
+  url?: string;
+  link?: string;
+  href?: string;
+  year?: string | number;
+  type?: string;
+  type_code?: string;
+  genre?: string | string[];
+  region?: string | string[];
+  quality?: string;
+  episode?: string | number;
+  status?: string;
+  rating?: string | number;
+  description?: string;
+  intro?: string;
+  summary?: string;
+  note?: string;
+  content?: string;
+  bio?: string;
+  [key: string]: unknown;
+}
+
+export interface DdysResource {
+  title?: string;
+  name?: string;
+  label?: string;
+  download_type?: string;
+  type?: string;
+  quality?: string;
+  url?: string;
+  link?: string;
+  href?: string;
+  [key: string]: unknown;
+}
+
+export interface DdysRequestInput {
+  title: string;
+  year?: string | number;
+  type?: 'movie' | 'series' | 'variety' | 'anime' | '';
+  description?: string;
+  douban_id?: string;
+  imdb_id?: string;
+  site?: string;
+  [key: string]: unknown;
+}
+
+export interface DdysDisplayOptions {
+  layout?: 'grid' | 'list' | 'compact';
+  theme?: 'auto' | 'light' | 'dark';
+  columns?: number;
+  target?: '_blank' | '_self';
+  showPoster?: boolean;
+  showRating?: boolean;
+  showSummary?: boolean;
+  showSourceLink?: boolean;
+}
+
+export interface DdysRouteHandlerContext {
+  params?: Record<string, string> | Promise<Record<string, string>>;
+}