@getquick/content 0.0.0-stage → 0.1.0

package/dist/wordpress-CPL40-vq.d.ts

@@ -0,0 +1,318 @@
+import { r as ConsentConfiguration, t as AnalyticsSettings } from "./configuration-C_JGygQI.js";
+import { r as LegalLanguage } from "./legal-C5Xiq59W.js";
+//#endregion
+//#region frontend/src/site-language.d.ts
+/**
+ * The `<html lang>` for a WordPress locale: its language and region as a
+ * BCP 47 tag (pt_PT_ao90 → pt-PT). WordPress's variants (ao90, formal) aren't
+ * BCP 47 subtags, so they are left out; no locale means English.
+ */
+declare function htmlLang(locale: string | undefined): string;
+/** A language the site serves. */
+interface SiteLanguage {
+  /** Its WordPress locale (pt_PT_ao90); empty when configuration names none. */
+  locale: string;
+  /** Polylang's slug, its URL directory: the default language's is its language code. */
+  slug: string;
+  /** Its GraphQL LanguageCodeEnum value: the slug in upper case (pt-br → PT_BR). */
+  code: string;
+  /** Its `<html lang>`. */
+  lang: string;
+  isDefault: boolean;
+  /** Its home route: / for the default language, /<slug>/ for the others. */
+  home: string;
+}
+interface WordPressLanguages {
+  locale?: string;
+  languages?: readonly {
+    locale: string;
+    slug: string;
+  }[];
+}
+/**
+ * configuration's languages: wordpress.locale, the default, served at /, then
+ * each of wordpress.languages under its slug. A monolingual Site has one.
+ */
+declare function siteLanguages(wordpress: WordPressLanguages | undefined): SiteLanguage[];
+/**
+ * A route's language: the one whose slug is its first segment, else the
+ * default language, which has no directory.
+ */
+declare function routeLanguage(route: string, among: readonly SiteLanguage[]): SiteLanguage;
+/**
+ * How logs and reports name something a language has: "the front page" for
+ * the default language's, "the en front page" for another's.
+ */
+declare function languageSubject(language: SiteLanguage, what: string): string;
+/** Whether a route is a language's home (/, /en/): served as a home, never as an entry. */
+declare function isLanguageHome(route: string, among: readonly SiteLanguage[]): boolean;
+declare namespace content_types_d_exports {
+  export { CmsFailure, CmsFailureReason, Delivery, DesignPresets, EntryContent, Found, HomeContent, Missing, PublishedEntry, SiteChrome, Translation, Unavailable, WordPressImage, WordPressMenuItem, WordPressPost, WordPressSettings };
+}
+interface WordPressImage {
+  sourceUrl: string;
+  altText: string;
+}
+interface WordPressPost {
+  id: string;
+  title: string;
+  excerpt: string;
+  content: string;
+  uri: string;
+  date: string;
+  featuredImage: WordPressImage | null;
+  hasVideoHero: boolean;
+}
+interface WordPressMenuItem {
+  id: string;
+  label: string;
+  href: string;
+  target: string | null;
+  children: WordPressMenuItem[];
+}
+interface WordPressSettings {
+  title: string;
+  description: string;
+}
+interface DesignPresets {
+  spacingSizes: Array<{
+    slug: string;
+    size: string;
+  }>;
+  colors: Array<{
+    slug: string;
+    color: string;
+  }>;
+}
+interface HomeContent extends DesignPresets {
+  /** The front page's WordPress entry (WPGraphQL's global id), if WordPress gave it. */
+  nodeId: string | null;
+  settings: WordPressSettings;
+  page: {
+    title: string;
+    content: string;
+    hasVideoHero: boolean;
+  };
+  /** WordPress failed on the blocks, so this is the page without them. */
+  blocksOmitted: boolean;
+}
+/** A published translation of an entry: its URI and its language's slug. */
+interface Translation {
+  uri: string;
+  language: string;
+}
+interface EntryContent extends WordPressPost, DesignPresets {
+  /** Its language's slug, on a multilingual Site. */
+  language?: string;
+  /** Its published translations into the site's other languages, on a multilingual Site. */
+  translations?: Translation[];
+  /** WordPress failed on the blocks, so this is the entry without them. */
+  blocksOmitted: boolean;
+  /** When WordPress last modified it (ms, the CMS's clock), if it said. */
+  modifiedAt: number | null;
+}
+/** A published page or post as WordPress lists it: its id, URI and last modification. */
+interface PublishedEntry {
+  /** WPGraphQL's global id, when WordPress gives it. */
+  id: string | null;
+  uri: string;
+  /** When WordPress last modified it (ms, the CMS's clock), if it said. */
+  modifiedAt: number | null;
+}
+interface SiteChrome {
+  menuItems: WordPressMenuItem[];
+  siteIcon: WordPressImage | null;
+  siteLogo: WordPressImage | null;
+  /**
+   * This language's LEGAL-1 Contract from gq-config, on a Site with consent
+   * CMS settings enabled (null when gq-config has none for it).
+   */
+  legal?: LegalLanguage | null;
+  /** gq-config's GA4 settings, on a Site with consent CMS settings enabled. */
+  analytics?: AnalyticsSettings;
+}
+/**
+ * Why WordPress couldn't deliver: it didn't answer in time (`timeout`), couldn't
+ * be reached (`network`), answered with an HTTP error (`http`) or GraphQL errors
+ * (`graphql`), or answered with data missing the fields the Frontend requires
+ * (`schema`).
+ */
+type CmsFailureReason = "timeout" | "network" | "http" | "graphql" | "schema";
+interface CmsFailure {
+  reason: CmsFailureReason;
+  message: string;
+  httpStatus?: number;
+}
+interface Found<T> {
+  kind: "found";
+  content: T;
+}
+/** WordPress answered with valid data, and has nothing published there. */
+interface Missing {
+  kind: "missing";
+}
+/** The content couldn't be read. This says nothing about whether it exists. */
+interface Unavailable {
+  kind: "unavailable";
+  failure: CmsFailure;
+}
+type Delivery<T> = Found<T> | Missing | Unavailable;
+//#endregion
+//#region frontend/src/bindings.d.ts
+interface SqlStatement {
+  bind(...values: unknown[]): SqlStatement;
+  first<T = Record<string, unknown>>(): Promise<T | null>;
+  all<T = Record<string, unknown>>(): Promise<{
+    results: T[];
+  }>;
+  run(): Promise<{
+    meta: {
+      changes: number;
+    };
+  }>;
+}
+interface SqlDatabase {
+  prepare(query: string): SqlStatement;
+  /** Runs the statements in order as one transaction: all of them apply, or none. */
+  batch<T = Record<string, unknown>>(statements: SqlStatement[]): Promise<Array<{
+    results: T[];
+  }>>;
+}
+interface ContentBindings {
+  /** The publication store (D1). */
+  PUBLICATION_DB?: SqlDatabase;
+  /** The trusted refresh's bearer token (a Worker secret). */
+  FRONTEND_REFRESH_TOKEN?: string;
+  /** The key the CMS signs its publication events with (a Worker secret). */
+  PUBLICATION_EVENT_SECRET?: string;
+  /** Read-only CMS edge identity; never the automation service or public env. */
+  GQ_AUTH_GRAPHQL_CLIENT_ID?: string;
+  GQ_AUTH_GRAPHQL_CLIENT_SECRET?: string;
+}
+//#endregion
+//#region frontend/src/page-types.d.ts
+/** The front page as stored: what WordPress delivered, without read details. */
+type HomePublication = Omit<HomeContent, "blocksOmitted" | "nodeId">;
+/** A published page or post as stored, with the design presets it was read with. */
+type EntryPublication = Omit<EntryContent, "blocksOmitted" | "modifiedAt">;
+/**
+ * A page in another language that a visitor of this one may switch to: its
+ * published translation (`translation`), or else that language's home.
+ */
+interface Alternate {
+  language: SiteLanguage;
+  route: string;
+  translation: boolean;
+}
+interface HomePage {
+  home: HomePublication;
+  chrome: SiteChrome;
+  /** The other languages' homes that are served; none on a monolingual Site. */
+  alternates: Alternate[];
+}
+interface EntryPage {
+  entry: EntryPublication;
+  chrome: SiteChrome;
+  /** Where its readers may switch language; none on a monolingual Site. */
+  alternates: Alternate[];
+}
+/** The entry a route served is published at another URI now: the route redirects there. */
+interface Moved {
+  kind: "moved";
+  uri: string;
+}
+/**
+ * Why there is nothing to serve: the CMS failed (live reads, in explicit development),
+ * the store couldn't be read (`store`), or the Site has never been refreshed,
+ * or holds only state this Frontend can't read (`not-ready`).
+ */
+type DeliveryFailureReason = CmsFailureReason | "store" | "not-ready";
+interface NotServed {
+  kind: "unavailable";
+  failure: {
+    reason: DeliveryFailureReason;
+    message: string;
+  };
+}
+type HomeDelivery = Found<HomePage> | (Missing & {
+  chrome: SiteChrome | null;
+}) | NotServed;
+type EntryDelivery = Found<EntryPage> | (Missing & {
+  chrome: SiteChrome | null;
+}) | Moved | NotServed;
+//#endregion
+//#region frontend/src/server.d.ts
+interface ContentConfig {
+  site: string;
+  graphqlEndpoint: string;
+  cmsOrigin: string;
+  wordpress?: WordPressLanguages;
+  /** Live delivery without a publication store is opt-in; false by default. */
+  development?: boolean;
+  isServer: () => boolean;
+  bindings: () => ContentBindings | Promise<ContentBindings>;
+  fetch?: typeof globalThis.fetch;
+  /**
+   * CONSENT-1 for this Site. Present, every published body's third-party
+   * embeds are rewritten into consent placeholders (unknown hosts blocked) on
+   * delivery; absent, bodies are delivered as published.
+   */
+  consent?: ContentConsentConfig;
+}
+interface ContentConsentConfig {
+  /** The catalog services the Site declares in code (e.g. "youtube", "google_maps"). */
+  services?: readonly string[];
+  /**
+   * Hosts that are the Site itself besides relative URLs: its Frontend and its
+   * CMS/media origin. The CMS origin is included by default.
+   */
+  firstPartyHosts?: readonly string[];
+  /**
+   * Read gq-config's Legal Contract and GA4 settings into each language's
+   * chrome (requires gq-config with the `getquickLegal` field). Their changes
+   * arrive as `legal` and `analytics` settings events.
+   */
+  cmsSettings?: boolean;
+}
+declare function createContentRuntime(input: ContentConfig): {
+  languages: SiteLanguage[];
+  defaultLanguage: SiteLanguage;
+  multilingual: boolean;
+  routeLanguage: (route: string) => SiteLanguage;
+  isLanguageHome: (route: string) => boolean;
+  wordpress: WordPressClient;
+  handleEvent: (request: Request, context?: {
+    siteOrigin?: string;
+  }) => Promise<Response>;
+  handleRefresh: (request: Request, context?: {
+    siteOrigin?: string;
+  }) => Promise<Response>;
+  publishedHome: (siteOrigin?: string, language?: SiteLanguage) => Promise<HomeDelivery>;
+  publishedEntry: (path: string, siteOrigin?: string) => Promise<EntryDelivery>;
+  pageChrome: (siteOrigin?: string) => Promise<SiteChrome | null>;
+  /**
+   * The Site's consent configuration for a page served with this chrome:
+   * declared services, GA4 when gq-config's toggle is on, and the
+   * controller from the Legal Contract. Null when consent isn't configured.
+   */
+  consentConfiguration: (chrome?: SiteChrome | null) => ConsentConfiguration | null;
+};
+type ContentRuntime = ReturnType<typeof createContentRuntime>;
+//#endregion
+//#region frontend/src/wordpress.d.ts
+interface WordPressClient {
+  getHomeContent(this: void, language?: SiteLanguage): Promise<Delivery<HomeContent>>;
+  getEntryByUri(this: void, uri: string): Promise<Delivery<EntryContent>>;
+  getDesignPresets(this: void): Promise<Found<DesignPresets> | Unavailable>;
+  getPublishedEntries(this: void): Promise<Found<{
+    entries: PublishedEntry[];
+    requests: number;
+  }> | Unavailable>;
+  getPublishedRoutes(this: void): Promise<Found<string[]> | Unavailable>;
+  getSiteChrome(this: void, siteOrigin?: string, options?: {
+    location?: string;
+    language?: SiteLanguage;
+  }): Promise<Found<SiteChrome> | Unavailable>;
+}
+//#endregion
+export { Unavailable as A, routeLanguage as B, EntryContent as C, PublishedEntry as D, Missing as E, SiteLanguage as F, WordPressLanguages as I, htmlLang as L, WordPressMenuItem as M, WordPressPost as N, SiteChrome as O, WordPressSettings as P, isLanguageHome as R, DesignPresets as S, HomeContent as T, siteLanguages as V, SqlDatabase as _, createContentRuntime as a, CmsFailureReason as b, EntryDelivery as c, HomeDelivery as d, HomePage as f, ContentBindings as g, NotServed as h, ContentRuntime as i, WordPressImage as j, Translation as k, EntryPage as l, Moved as m, ContentConfig as n, Alternate as o, HomePublication as p, ContentConsentConfig as r, DeliveryFailureReason as s, WordPressClient as t, EntryPublication as u, SqlStatement as v, Found as w, Delivery as x, CmsFailure as y, languageSubject as z };

package/migrations/0001_publications.sql

@@ -0,0 +1,31 @@
+-- The Frontend's durable published content: the last-known-good public
+-- representation of each published thing ("home", "chrome"), and the outcome
+-- of the last refresh of each. Alchemy applies these files in order on deploy
+-- (infra/frontend.run.ts), before the Worker is updated, so a migration must
+-- keep working with the Worker version it replaces: add, never rewrite.
+
+CREATE TABLE publications (
+  -- What the row is: "home" (the front page), "chrome" (menu, logo, icon).
+  key TEXT PRIMARY KEY,
+  -- "published" (body holds it) or "missing" (the CMS confirmed nothing is
+  -- published there).
+  state TEXT NOT NULL,
+  -- The version of body's shape. A Worker only serves the formats it knows.
+  format INTEGER NOT NULL,
+  body TEXT,
+  -- When the CMS read behind this row started (ms since the epoch). A
+  -- promotion only replaces a row whose read started earlier, so a slow or
+  -- delayed refresh can't overwrite a newer one.
+  read_started_at INTEGER NOT NULL,
+  promoted_at INTEGER NOT NULL
+);
+
+CREATE TABLE refresh_attempts (
+  key TEXT PRIMARY KEY,
+  attempted_at INTEGER NOT NULL,
+  -- "promoted", "superseded" (a newer read was already promoted) or "kept"
+  -- (the read failed, so the stored row was left as it was).
+  outcome TEXT NOT NULL,
+  reason TEXT,
+  message TEXT
+);

package/migrations/0002_entries.sql

@@ -0,0 +1,14 @@
+-- Published entries (pages and posts), one row each in publications, keyed
+-- "entry:<uri>". Added for them, and harmless to the Worker version before:
+-- it never names node_id, so its writes leave it NULL.
+
+-- Which WordPress post or page a row holds (WPGraphQL's global id), so a
+-- refresh that finds it at another URI can reconcile the route it left, and
+-- a later withdrawal can find every route that served it.
+ALTER TABLE publications ADD COLUMN node_id TEXT;
+
+CREATE INDEX publications_node_id ON publications (node_id);
+
+-- publications.state gains "moved": the entry the row held is published at
+-- another URI now (body: {"uri": "<its URI>"}), so the route redirects there
+-- instead of presenting its superseded copy as current.

package/migrations/0003_publication_events.sql

@@ -0,0 +1,36 @@
+-- The CMS's publication events (POST /gq/events): one row per event the
+-- Frontend accepted, so a duplicate is recognised, a delayed one can't undo a
+-- newer one, and one whose refresh failed stays on record for a retry. Added
+-- for them, and harmless to the Worker version before: it never reads it.
+
+CREATE TABLE publication_events (
+  -- The event's identity, chosen by the CMS (a UUID). A delivery of an id
+  -- already recorded is a duplicate, or a retry of one that failed.
+  id TEXT PRIMARY KEY,
+  -- What happened: "publish" (a page or post was published or updated).
+  action TEXT NOT NULL,
+  -- The WordPress entry it is about (WPGraphQL's global id), as in
+  -- publications.node_id.
+  node_id TEXT NOT NULL,
+  -- The entry's URI when the event happened, and the one it had before, if it
+  -- moved.
+  uri TEXT NOT NULL,
+  previous_uri TEXT,
+  -- When it happened in the CMS (ms since the epoch): the order of one
+  -- entry's events. An event older than one already refreshed for the same
+  -- entry is superseded, never processed.
+  occurred_at INTEGER NOT NULL,
+  received_at INTEGER NOT NULL,
+  -- "received" (not processed yet, or interrupted), "refreshed", "failed"
+  -- (its refresh kept the stored versions; a retry may process it again) or
+  -- "superseded" (a newer event for the entry was refreshed).
+  status TEXT NOT NULL,
+  attempts INTEGER NOT NULL DEFAULT 0,
+  processed_at INTEGER,
+  -- Why it failed, when it did (a refresh failure reason and its message).
+  reason TEXT,
+  message TEXT
+);
+
+CREATE INDEX publication_events_node ON publication_events (node_id, occurred_at);
+CREATE INDEX publication_events_status ON publication_events (status, received_at);

package/migrations/0004_withdrawals.sql

@@ -0,0 +1,30 @@
+-- The CMS's withdrawals (a page or post unpublished, made private or
+-- password-protected, trashed or deleted): one row per WordPress entry whose
+-- last accepted lifecycle event withdrew it. While a withdrawal is in force,
+-- nothing promotes that entry's content again, whatever a read returns; only a
+-- publication event that happened after it lifts it. Added for them, and
+-- harmless to the Worker version before: it never reads this table, and a
+-- "withdrawn" row is a state it doesn't know, so it serves it as a 503, never
+-- as content.
+
+CREATE TABLE withdrawals (
+  -- The WordPress entry (WPGraphQL's global id), as in publications.node_id.
+  node_id TEXT PRIMARY KEY,
+  -- The withdraw event in force (publication_events.id) and the URI the entry
+  -- had while it was published.
+  event_id TEXT NOT NULL,
+  uri TEXT NOT NULL,
+  -- When it happened in the CMS (ms since the epoch), and when the Frontend
+  -- accepted it (ms, the Frontend's clock).
+  withdrawn_at INTEGER NOT NULL,
+  accepted_at INTEGER NOT NULL,
+  -- The newer publication event that lifted it, and when that happened in the
+  -- CMS. NULL while the withdrawal is in force.
+  republished_by TEXT,
+  republished_at INTEGER
+);
+
+-- publications.state gains "withdrawn": the entry the row held was withdrawn
+-- (body NULL). It is a 404, and nothing older than the withdrawal replaces it.
+-- publication_events.action gains "withdraw"; one that was applied is
+-- recorded "refreshed", like a publication: the store is up to date with it.

package/migrations/0005_reconciliation.sql

@@ -0,0 +1,45 @@
+-- Reconciliation (ADR 0009): the CMS's scheduler asks the Frontend, every
+-- minute, to compare its publication store with what WordPress publishes and
+-- to refresh what differs, so a change whose event never arrived still
+-- reaches visitors. Added for it, and harmless to the Worker version before:
+-- it never names these columns or this table.
+
+-- When WordPress last modified the entry a row holds (ms since the epoch, the
+-- CMS's clock: WPGraphQL's modifiedGmt), as the read that promoted it saw it.
+-- NULL for rows promoted before this column, or by a read without it: a
+-- reconciliation reads those again.
+ALTER TABLE publications ADD COLUMN modified_at INTEGER;
+
+-- The Site's reconciliation: one row, holding the lease that keeps two runs
+-- from overlapping and the outcome of the last run, for diagnostics.
+CREATE TABLE reconciliation (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  -- The run holding the lease (the reconcile event's id), and until when (ms).
+  -- A run that was interrupted leaves it to expire.
+  run_id TEXT,
+  lease_until INTEGER NOT NULL DEFAULT 0,
+  started_at INTEGER,
+  finished_at INTEGER,
+  -- "reconciled" (nothing differs any more), "behind" (changes left for the
+  -- next run) or "failed" (a read or a refresh failed; what was stored is
+  -- kept).
+  outcome TEXT,
+  -- What the last run found: the published entries it compared, the changes it
+  -- refreshed, those it left for the next run, and those whose refresh failed.
+  checked INTEGER,
+  changed INTEGER,
+  pending INTEGER,
+  failed INTEGER,
+  -- The first failure's reason and message (no content, no secret).
+  reason TEXT,
+  message TEXT,
+  -- When the last run that left nothing behind started: the store matched
+  -- WordPress as of then.
+  reconciled_at INTEGER
+);
+
+-- Reconciliation records the change it found in an entry, when WordPress
+-- gives its id and modification time, as a publication event in
+-- publication_events (an id starting "reconcile-", the same for the same
+-- change, and occurred_at its modification time), so it is processed, ordered
+-- and retried by the same rules as one the CMS sent.

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "@getquick/content",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "migrations",
+    "consent-migrations"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./migrations": {
+      "types": "./dist/migrations.d.ts",
+      "import": "./dist/migrations.js"
+    },
+    "./consent": {
+      "types": "./dist/consent.d.ts",
+      "import": "./dist/consent.js"
+    },
+    "./consent/client": {
+      "types": "./dist/consent-client.d.ts",
+      "import": "./dist/consent-client.js"
+    },
+    "./consent/server": {
+      "types": "./dist/consent-server.d.ts",
+      "import": "./dist/consent-server.js"
+    },
+    "./consent/migrations": {
+      "types": "./dist/consent-migrations.d.ts",
+      "import": "./dist/consent-migrations.js"
+    },
+    "./consent/astro": {
+      "types": "./dist/consent-astro.d.ts",
+      "import": "./dist/consent-astro.js"
+    },
+    "./consent/testing": {
+      "types": "./dist/consent-testing.d.ts",
+      "import": "./dist/consent-testing.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "zod": "3.25.76"
+  },
+  "engines": {
+    "node": ">=22"
+  }
 }