@acms-subir/core 0.3.2 → 0.3.3

package/src/lib/editor/token-route.ts

@@ -0,0 +1,74 @@
+import type { APIContext } from 'astro';
+import { getRepo } from '../repo';
+import { ApiError, readResponseBytes } from '../api';
+import { sha256Hex } from '../api-keys';
+import { OAuthError, revokeToken, tokenGrant, bearerToken } from './auth';
+import { requireEditorApps } from './config';
+
+// POST /api/v1/auth/token and /api/v1/auth/revoke. OAuth-shaped responses
+// (RFC 6749 §5): top-level fields, errors as { error, error_description },
+// so standard clients (expo-auth-session) work unchanged. Bodies only —
+// secrets are never accepted in the query string.
+
+const headers = {
+  'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Methods': 'POST, OPTIONS', 'Access-Control-Allow-Headers': 'Authorization, Content-Type',
+  'Cache-Control': 'no-store', Pragma: 'no-cache', 'X-Content-Type-Options': 'nosniff',
+};
+export const authPreflight = () => new Response(null, { status: 204, headers });
+const reply = (body: unknown, status = 200, extra: Record<string, string> = {}) => Response.json(body, { status, headers: { ...headers, ...extra } });
+
+async function readForm(request: Request): Promise<Record<string, string>> {
+  const type = request.headers.get('content-type')?.toLowerCase() ?? '';
+  const bytes = await readResponseBytes(request, 10_000);
+  const text = new TextDecoder().decode(bytes);
+  const out: Record<string, string> = {};
+  if (type.startsWith('application/x-www-form-urlencoded')) {
+    for (const [k, v] of new URLSearchParams(text)) {
+      if (k in out) throw new OAuthError(400, 'invalid_request', `Duplicate parameter: ${k}.`);
+      out[k] = v;
+    }
+  } else if (type.startsWith('application/json')) {
+    let json: unknown;
+    try { json = JSON.parse(text); } catch { throw new OAuthError(400, 'invalid_request', 'Body must be valid JSON.'); }
+    if (!json || typeof json !== 'object' || Array.isArray(json)) throw new OAuthError(400, 'invalid_request', 'Body must be an object.');
+    for (const [k, v] of Object.entries(json)) if (typeof v === 'string') out[k] = v;
+  } else throw new OAuthError(415, 'invalid_request', 'Use Content-Type: application/x-www-form-urlencoded (or application/json).');
+  return out;
+}
+const address = (context: APIContext) => { try { return context.clientAddress || 'unknown'; } catch { return 'unknown'; } };
+
+function oauthFailure(error: unknown) {
+  if (error instanceof OAuthError) return reply({ error: error.error, error_description: error.message }, error.status);
+  if (error instanceof ApiError) {
+    if (error.status === 429) return reply({ error: 'rate_limited', error_description: error.message }, 429, { 'Retry-After': '60' });
+    if (error.status === 404) return reply({ error: 'not_found', error_description: error.message }, 404);
+    return reply({ error: 'invalid_request', error_description: error.message }, error.status);
+  }
+  console.error('acms editor auth: token request failed');
+  return reply({ error: 'server_error', error_description: 'Request failed. Please try again.' }, 500);
+}
+
+export async function tokenRoute(context: APIContext) {
+  try {
+    requireEditorApps();
+    if (context.url.search) throw new OAuthError(400, 'invalid_request', 'Send parameters in the request body, not the URL.');
+    const repo = await getRepo(context.locals);
+    if (!await repo.email.rateLimit(`editor:token:${await sha256Hex(address(context))}`, 30, 60_000)) throw new ApiError(429, 'Too many requests. Try again in a minute.');
+    return reply(await tokenGrant(repo, await readForm(context.request)));
+  } catch (error) { return oauthFailure(error); }
+}
+
+export async function revokeRoute(context: APIContext) {
+  try {
+    requireEditorApps();
+    if (context.url.search) throw new OAuthError(400, 'invalid_request', 'Send parameters in the request body, not the URL.');
+    const repo = await getRepo(context.locals);
+    if (!await repo.email.rateLimit(`editor:revoke:${await sha256Hex(address(context))}`, 30, 60_000)) throw new ApiError(429, 'Too many requests. Try again in a minute.');
+    const form = context.request.headers.get('content-type') ? await readForm(context.request) : {};
+    const token = form.token || bearerToken(context.request);
+    if (!token) throw new OAuthError(400, 'invalid_request', 'Send the token to revoke.');
+    await revokeToken(repo, token);
+    // RFC 7009: unknown or already-revoked tokens also succeed
+    return reply({ revoked: true });
+  } catch (error) { return oauthFailure(error); }
+}

package/src/lib/editor/translations.ts

@@ -0,0 +1,163 @@
+import { z } from 'zod';
+import type { ContentRepository } from '../repo/types';
+import { DocTranslation, type DocTranslations } from '../schema';
+import { ApiError } from '../api';
+import { I18N } from '../i18n';
+import { isExtraLocale } from '../translations';
+import { translateUnits } from '../translate';
+import { textHash, translationUnits } from '../../theme-sdk/fields.mjs';
+import type { SaveHooks } from '../content-service';
+import type { EditorPrincipal } from './auth';
+import { checkRevision, loadDoc, mergedDoc, revisionOf, saveRaw, withDocLock, type DocKind } from './documents';
+import { findSection, stagedPages, stagedTheme, stageSection } from './sections';
+
+// Translations for editor apps, same rules as the web editors: a person
+// setting a text marks it reviewed; AI drafts are stored as "AI draft" for
+// review; "mark reviewed" confirms every translated unit against the current
+// main-language text. Documents save through the content service (live ones
+// stage), sections through the shared design rules (locks apply).
+
+type State = 'ai' | 'reviewed';
+type Meta = Record<string, { state: State; src: string }>;
+interface Unit { path: string; label: string; kind: 'text' | 'textarea' | 'richtext' | 'link' | 'select'; source: string; hash: string }
+export type TranslationStatus = 'missing' | 'ai' | 'reviewed' | 'outdated';
+
+const pathList = z.array(z.string().max(300)).max(500);
+export const SetDocInput = z.object({ revision: z.string().max(60), values: z.record(z.string().max(300), z.string().max(2_000_000)) }).strict();
+export const SetSectionInput = z.object({ revision: z.number().int().nonnegative(), values: z.record(z.string().max(300), z.string().max(60_000)) }).strict();
+export const ReviewDocInput = z.object({ revision: z.string().max(60), paths: pathList.optional() }).strict();
+export const ReviewSectionInput = z.object({ revision: z.number().int().nonnegative(), paths: pathList.optional() }).strict();
+export const AiDocInput = ReviewDocInput.extend({ includeReviewed: z.boolean().default(false) }).strict();
+export const AiSectionInput = ReviewSectionInput.extend({ includeReviewed: z.boolean().default(false) }).strict();
+
+export function requireLocale(locale: string) {
+  if (!isExtraLocale(locale)) throw new ApiError(404, I18N.enabled ? `“${locale}” isn’t one of this site’s extra languages.` : 'This site has one language.');
+}
+
+// ---- documents -------------------------------------------------------------
+
+const DOC_FIELDS: Record<DocKind, [string, string, Unit['kind']][]> = {
+  post: [['title', 'Title', 'text'], ['excerpt', 'Excerpt', 'textarea'], ['bodyHtml', 'Body', 'richtext'], ['seoTitle', 'Search title', 'text'], ['seoDesc', 'Search description', 'textarea']],
+  page: [['title', 'Title', 'text'], ['bodyHtml', 'Body', 'richtext'], ['seoTitle', 'Search title', 'text'], ['seoDesc', 'Search description', 'textarea']],
+  event: [['title', 'Title', 'text'], ['excerpt', 'Summary', 'textarea'], ['bodyHtml', 'Description', 'richtext'], ['seoTitle', 'Search title', 'text'], ['seoDesc', 'Search description', 'textarea'],
+    ['locationName', 'Place name', 'text'], ['ctaLabel', 'Button label', 'text']],
+};
+const emptyDocTr = () => DocTranslation.parse({});
+
+function docUnits(kind: DocKind, doc: Record<string, unknown>): Unit[] {
+  const main = (f: string) => f === 'locationName' ? String((doc.location as { name?: string } | undefined)?.name ?? '')
+    : f === 'ctaLabel' ? String((doc.cta as { label?: string } | undefined)?.label ?? '') : String(doc[f] ?? '');
+  return DOC_FIELDS[kind].map(([path, label, k]) => ({ path, label, kind: k, source: main(path), hash: textHash(main(path)) })).filter((u) => u.source.trim());
+}
+function status(u: Unit, value: string, meta: Meta): TranslationStatus {
+  if (!value.trim()) return 'missing';
+  const m = meta[u.path];
+  if (m && m.src !== u.hash) return 'outdated';
+  return m?.state === 'reviewed' ? 'reviewed' : 'ai';
+}
+function view(units: Unit[], values: Record<string, unknown>, meta: Meta) {
+  const list = units.map((u) => { const value = String(values[u.path] ?? ''); return { path: u.path, label: u.label, kind: u.kind, source: u.source, value, status: status(u, value, meta) }; });
+  const summary = { total: list.length, missing: 0, ai: 0, reviewed: 0, outdated: 0 };
+  for (const u of list) summary[u.status]++;
+  return { units: list, summary };
+}
+
+type Mode = { op: 'set'; values: Record<string, string> } | { op: 'review'; paths?: string[] } | { op: 'ai'; paths?: string[]; includeReviewed: boolean };
+/** apply one operation to a translation's values + review meta; returns how many units changed */
+async function applyMode(units: Unit[], values: Record<string, unknown>, meta: Meta, mode: Mode, locale: string, repo: ContentRepository, locals: unknown): Promise<number> {
+  const byPath = new Map(units.map((u) => [u.path, u]));
+  const pick = (paths?: string[]) => {
+    if (!paths) return units;
+    const unknown = paths.find((p) => !byPath.has(p));
+    if (unknown) throw new ApiError(400, `Nothing to translate at “${unknown}”.`);
+    return paths.map((p) => byPath.get(p)!);
+  };
+  if (mode.op === 'set') {
+    const entries = Object.entries(mode.values);
+    if (!entries.length) throw new ApiError(400, 'Send at least one value.');
+    for (const [path, value] of entries) {
+      const u = byPath.get(path);
+      if (!u) throw new ApiError(400, `Nothing to translate at “${path}”.`);
+      values[path] = value;
+      // a person wrote it: reviewed, against the current main-language text
+      if (value.trim()) meta[path] = { state: 'reviewed', src: u.hash }; else delete meta[path];
+    }
+    return entries.length;
+  }
+  if (mode.op === 'review') {
+    let n = 0;
+    for (const u of pick(mode.paths)) if (String(values[u.path] ?? '').trim()) { meta[u.path] = { state: 'reviewed', src: u.hash }; n++; }
+    return n;
+  }
+  const todo = pick(mode.paths).filter((u) => {
+    const st = status(u, String(values[u.path] ?? ''), meta);
+    return st === 'missing' || (st === 'outdated' && (mode.includeReviewed || meta[u.path]?.state !== 'reviewed')) || (mode.includeReviewed && (st === 'ai' || st === 'reviewed'));
+  });
+  if (!todo.length) return 0;
+  const { results } = await translateUnits((await repo.getSettings()).ai, { locale, units: todo.map((u) => ({ id: u.path, text: u.source, kind: u.kind, label: u.label.slice(0, 200) })) }, locals);
+  let n = 0;
+  for (const u of todo) if (results[u.path] !== undefined) { values[u.path] = results[u.path]; meta[u.path] = { state: 'ai', src: u.hash }; n++; }
+  return n;
+}
+
+export async function getDocTranslation(repo: ContentRepository, kind: DocKind, id: string, locale: string) {
+  requireLocale(locale);
+  const raw = await loadDoc(repo, kind, id);
+  const doc = mergedDoc(kind, raw) as unknown as Record<string, unknown> & { translations?: DocTranslations };
+  const tr = doc.translations?.[locale] ?? emptyDocTr();
+  return { locale, revision: revisionOf(raw), ...view(docUnits(kind, doc), tr as unknown as Record<string, unknown>, tr.meta as Meta) };
+}
+
+export async function changeDocTranslation(repo: ContentRepository, kind: DocKind, id: string, locale: string, revision: string, mode: Mode, hooks: SaveHooks) {
+  requireLocale(locale);
+  const changed = await withDocLock(repo, kind, id, () => changeDocTranslationLocked(repo, kind, id, locale, revision, mode, hooks));
+  return { changed, ...(await getDocTranslation(repo, kind, id, locale)) };
+}
+async function changeDocTranslationLocked(repo: ContentRepository, kind: DocKind, id: string, locale: string, revision: string, mode: Mode, hooks: SaveHooks) {
+  const raw = await loadDoc(repo, kind, id);
+  checkRevision(raw, revision);
+  const doc = mergedDoc(kind, raw) as unknown as Record<string, unknown> & { translations?: DocTranslations };
+  const current = doc.translations?.[locale] ?? emptyDocTr();
+  const next = { ...current, meta: { ...current.meta } } as Record<string, unknown> & { meta: Meta };
+  const changed = await applyMode(docUnits(kind, doc), next, next.meta, mode, locale, repo, hooks.locals);
+  if (changed) {
+    const parsed = DocTranslation.parse(next);
+    await saveRaw(repo, kind, id, { translations: { ...(doc.translations ?? {}), [locale]: parsed } }, hooks);
+  }
+  return changed;
+}
+
+// ---- sections --------------------------------------------------------------
+
+export async function getSectionTranslation(repo: ContentRepository, pageId: string, sectionId: string, locale: string) {
+  requireLocale(locale);
+  const settings = await repo.getSettings();
+  const section = findSection(stagedPages(settings), pageId, sectionId);
+  const def = (await stagedTheme(settings)).sections[section.type];
+  if (!def) throw new ApiError(409, `The “${section.type}” section isn’t available in this theme.`);
+  const tr = section.translations?.[locale] ?? { data: {}, meta: {} };
+  const units: Unit[] = translationUnits(def, section.data).map((u) => ({ path: u.path, label: u.label, kind: u.kind as Unit['kind'], source: u.source, hash: u.hash }));
+  return { locale, revision: settings.designRevision, ...view(units, tr.data, tr.meta as Meta) };
+}
+
+export async function changeSectionTranslation(repo: ContentRepository, who: EditorPrincipal, pageId: string, sectionId: string, locale: string, revision: number, mode: Mode, origin: string, locals: unknown) {
+  requireLocale(locale);
+  const settings = await repo.getSettings();
+  if (settings.designRevision !== revision) throw new ApiError(409, 'Design changed. Pull the latest revision before saving.');
+  const section = findSection(stagedPages(settings), pageId, sectionId);
+  const def = (await stagedTheme(settings)).sections[section.type];
+  if (!def) throw new ApiError(409, `The “${section.type}” section isn’t available in this theme.`);
+  if (section.locked && who.user.role !== 'owner') throw new ApiError(403, `Only an owner can edit the locked “${def.name}” section.`);
+  const units: Unit[] = translationUnits(def, section.data).map((u) => ({ path: u.path, label: u.label, kind: u.kind as Unit['kind'], source: u.source, hash: u.hash }));
+  const cur = section.translations?.[locale] ?? { data: {}, meta: {} };
+  const next = { data: { ...cur.data } as Record<string, unknown>, meta: { ...cur.meta } as Meta };
+  const changed = await applyMode(units, next.data, next.meta, mode, locale, repo, locals);
+  let newRevision = revision;
+  if (changed) {
+    for (const [k, v] of Object.entries(next.data)) if (v === '') { delete next.data[k]; delete next.meta[k]; }
+    const result = await stageSection(repo, who, revision, pageId, sectionId,
+      (s) => ({ ...s, translations: { ...(s.translations ?? {}), [locale]: next as NonNullable<typeof s.translations>[string] } }), origin);
+    newRevision = result.revision;
+  }
+  return { changed, ...(await getSectionTranslation(repo, pageId, sectionId, locale)), revision: newRevision };
+}

package/src/lib/email/accounts.ts

@@ -1,3 +1,4 @@
+import type { Role } from '../schema';
 import { randomBytes } from 'node:crypto';
 import type { ContentRepository } from '../repo/types';
 import { hashPassword, verifyPassword, checkPassword, OWNER_ENV } from '../auth';
@@ -27,7 +28,7 @@ export async function reauthenticate(repo:ContentRepository, userId:string, pass
   const user=await repo.getUser(userId); if(!user)return false;
   const auth=await repo.getUserAuth(user.email);return !!auth && verifyPassword(password,auth.passHash);
 }
-export async function issueAccountToken(repo:ContentRepository, data:{purpose:'invite'|'reset';email:string;name?:string;role?:'owner'|'editor';expiresDays?:number}, locals?:unknown) {
+export async function issueAccountToken(repo:ContentRepository, data:{purpose:'invite'|'reset';email:string;name?:string;role?:Role;expiresDays?:number}, locals?:unknown) {
   const email=data.email.trim().toLowerCase();
   if(!validAddress(email))throw new Error('Enter a valid email address.');
   const auth=await repo.getUserAuth(email);

package/src/lib/email/types.ts

@@ -1,3 +1,4 @@
+import type { Role } from '../schema';
 export type Provider = 'resend' | 'mailgun' | 'ses' | 'cloudflare';
 export type ProviderChoice = Provider | 'auto' | 'none';
 export interface Attachment { filename: string; type: string; content: string }
@@ -20,7 +21,7 @@ export interface EmailJob {
 }
 export interface NewEmailJob { id?: string; dedupe: string; kind: string; recipient: string; payload: string; configVersion: number; nextAt?: number; expiresAt?: number }
 export type SendResult = { state: 'accepted'; providerId: string } | { state: 'retrying' | 'failed' | 'unknown'; error: string; retryAfter?: number };
-export interface Invitation { id: string; email: string; name: string; role: 'owner' | 'editor'; state: string; expiresAt: number; createdAt: number }
+export interface Invitation { id: string; email: string; name: string; role: Role; state: string; expiresAt: number; createdAt: number }
 export interface PublicEmailSettings {
   version: number; config: EmailConfig; provider: Provider | 'none'; configured: boolean; error: string;
   encryptionAvailable: boolean; environmentLocked: boolean; credentialFields: string[];

package/src/lib/home-source.ts

@@ -0,0 +1,34 @@
+import type { Page, Settings } from './schema';
+import { resolveDesign } from './theme';
+
+// Which homepage do visitors actually get? Mirrors pages/index.astro:
+//   1. the home page has a section layout in 'sections' mode → sections
+//   2. else the active theme ships templates/home.astro and neither the
+//      Design screen nor the page forces 'content' → coded template
+//   3. else → this page's own content
+// The page editor uses it to point people at the right place, instead of
+// letting them edit text that isn't what the homepage shows.
+
+export type HomeSource =
+  | { kind: 'content' }
+  | { kind: 'sections'; editUrl: string; showsPageContent: boolean; sections: number }
+  | { kind: 'template'; editUrl: string; theme: string; file: string };
+
+export function homeSource(settings: Settings, page: Pick<Page, 'id' | 'isHome'>): HomeSource {
+  if (!page.isHome) return { kind: 'content' };
+  const layout = settings.sectionPages?.[page.id];
+  if (layout?.mode === 'sections') {
+    const visible = layout.sections.filter((s) => !s.hidden);
+    return {
+      kind: 'sections',
+      editUrl: `/admin/design?page=${encodeURIComponent(page.id)}#pages`,
+      showsPageContent: visible.some((s) => s.type === 'page-content'),
+      sections: visible.length,
+    };
+  }
+  const design = resolveDesign(settings);
+  if (design.HomeTemplate && design.homeMode !== 'content' && layout?.mode !== 'content') {
+    return { kind: 'template', editUrl: '/admin/design', theme: design.theme.name, file: `src/themes/${design.theme.slug}/templates/home.astro` };
+  }
+  return { kind: 'content' };
+}

package/src/lib/i18n.ts

@@ -38,3 +38,37 @@ export function normalizePageLocale(locale: string): string {
   if (!locale || locale === I18N.defaultLocale) return '';
   return I18N.locales.includes(locale) ? locale : '';
 }
+
+const NAMES: Record<string, string> = { en: 'English', es: 'Spanish', fr: 'French', de: 'German', pt: 'Portuguese', it: 'Italian', nl: 'Dutch', ko: 'Korean', zh: 'Chinese', ja: 'Japanese', tl: 'Tagalog', vi: 'Vietnamese', ar: 'Arabic', ru: 'Russian', uk: 'Ukrainian', pl: 'Polish', ht: 'Haitian Creole' };
+const NATIVE: Record<string, string> = { en: 'English', es: 'Español', fr: 'Français', de: 'Deutsch', pt: 'Português', it: 'Italiano', nl: 'Nederlands', ko: '한국어', zh: '中文', ja: '日本語', tl: 'Tagalog', vi: 'Tiếng Việt', ar: 'العربية', ru: 'Русский', uk: 'Українська', pl: 'Polski', ht: 'Kreyòl' };
+/** "es" → "Spanish" (for AI prompts); native: "es" → "Español" (for people) */
+export function localeName(code: string, native = false): string {
+  const base = code.split('-')[0];
+  return (native ? NATIVE : NAMES)[base] ?? code;
+}
+
+/** the extra (non-default) languages */
+export const extraLocales = (): string[] => (I18N.enabled ? I18N.locales.filter((l) => l !== I18N.defaultLocale) : []);
+
+/** a request's language: set by the middleware for /<locale>/… rewrites, else from the path */
+export function requestLocale(url: URL, locals?: unknown): string {
+  const fromLocals = (locals as { acmsLocale?: string } | undefined)?.acmsLocale;
+  return fromLocals || localeFromPath(url.pathname);
+}
+
+/** "/events/x" in a language: "/es/events/x"; the default language has no prefix */
+export function localePath(path: string, locale: string): string {
+  const bare = stripLocale(path);
+  if (!locale || locale === I18N.defaultLocale || !I18N.enabled) return bare;
+  return bare === '/' ? `/${locale}` : `/${locale}${bare}`;
+}
+
+/** drop a leading non-default locale prefix: "/es/events/x" → "/events/x", "/es" → "/" */
+export function stripLocale(path: string): string {
+  for (const l of I18N.locales) {
+    if (l === I18N.defaultLocale) continue;
+    if (path === `/${l}`) return '/';
+    if (path.startsWith(`/${l}/`)) return path.slice(l.length + 1);
+  }
+  return path || '/';
+}