emdash 1.3.1 → 1.4.0

package/dist/utils-Szp4iBQB.d.mts

@@ -0,0 +1,376 @@
+import { n as ContentBylineCredit, t as BylineSummary, u as FindManyResult } from "./types-C4KT3Md2.mjs";
+import { t as Database } from "./types-DKwRUA-x.mjs";
+import { Kysely } from "kysely";
+import { slugify } from "@emdash-cms/admin/slugify";
+import { PortableTextBlock } from "@emdash-cms/gutenberg-to-portable-text";
+
+//#region src/database/repositories/byline.d.ts
+interface CreateBylineInput {
+  slug: string;
+  displayName: string;
+  bio?: string | null;
+  avatarMediaId?: string | null;
+  websiteUrl?: string | null;
+  userId?: string | null;
+  isGuest?: boolean;
+  /**
+   * Locale this byline row belongs to. When omitted, the DB DEFAULT (the
+   * configured `defaultLocale` after migration 040) is used. Keeps behaviour
+   * consistent with `TaxonomyRepository.create`.
+   */
+  locale?: string;
+  /**
+   * When set, the new row joins the source byline's translation_group rather
+   * than minting a fresh one. The source must exist; otherwise the create
+   * throws. Mirrors `TaxonomyRepository.create`.
+   */
+  translationOf?: string;
+  /**
+   * Byline custom-field values to seed on the new row (Phase 6 of
+   * Discussion #1174). Same semantics as `UpdateBylineInput.customFields`:
+   * keys must match registered slugs in `_emdash_byline_fields`, values
+   * are validated against the field's type, and writes route to
+   * `_emdash_byline_field_values` (translatable) or
+   * `_emdash_byline_field_group_values` (group-shared). Validation runs
+   * before the row insert so a bad value can't leave a bare byline behind.
+   */
+  customFields?: Record<string, unknown>;
+}
+interface UpdateBylineInput {
+  slug?: string;
+  displayName?: string;
+  bio?: string | null;
+  avatarMediaId?: string | null;
+  websiteUrl?: string | null;
+  userId?: string | null;
+  isGuest?: boolean;
+  /**
+   * Byline custom-field values to write (Phase 3 of Discussion #1174).
+   *
+   * Each key must match a registered slug in `_emdash_byline_fields`;
+   * unknown keys throw `EmDashValidationError`. Per-field writes route
+   * to `_emdash_byline_field_values` (when the field's `translatable`
+   * flag is true) or `_emdash_byline_field_group_values` (when false).
+   * A value of `null` clears the row.
+   *
+   * Values are validated against the field's type:
+   * - `string` / `text` / `url` accept a `string`
+   * - `boolean` accepts a `boolean`
+   * - `select` accepts a `string` that appears in `validation.options`
+   *
+   * Writes are idempotent (`INSERT … ON CONFLICT DO UPDATE`), so
+   * retrying the same update produces the same DB state.
+   */
+  customFields?: Record<string, unknown>;
+}
+interface ContentBylineInput {
+  bylineId: string;
+  roleLabel?: string | null;
+}
+/**
+ * Byline repository for content credits.
+ *
+ * Bylines are per-locale (migration 040). Translations of the same byline
+ * share a `translation_group` ULID. `_emdash_content_bylines.byline_id` and
+ * `ec_*.primary_byline_id` store the translation_group (not a row id) so a
+ * single credit spans every locale variant of a byline.
+ *
+ * The repository does not resolve locale fallbacks on its own — callers
+ * supply the locale they want. Hydration is strict per locale: a credit at
+ * locale X renders iff a byline row exists at locale X within the credited
+ * translation group. This mirrors `TaxonomyRepository.getTermsForEntry` and
+ * the convention established by PR #916.
+ *
+ * Runtime helpers in `packages/core/src/bylines/index.ts` may layer fallback
+ * resolution on top for the "look up one byline by slug" path, but the
+ * relation-hydration methods on this class are always strict.
+ */
+declare class BylineRepository {
+  private db;
+  constructor(db: Kysely<Database>);
+  /**
+   * Merge `customFields` onto each `BylineSummary` produced from the
+   * given rows. Two batched queries total — one against
+   * `_emdash_byline_field_values` (keyed by `byline_id`), one against
+   * `_emdash_byline_field_group_values` (keyed by `translation_group`)
+   * — both chunked at `SQL_BATCH_SIZE` for D1's bound-parameter cap.
+   *
+   * When zero fields are registered, every row gets `customFields = {}`
+   * with no value-table reads (the field-defs cache returns `[]`).
+   * Group-shared values are looked up via the row's `translation_group`,
+   * so every locale sibling of the same byline identity sees the same
+   * non-translatable value without re-reading per row.
+   *
+   * **Duplicate-row handling.** Callers (notably `getContentBylinesMany`
+   * for list views with repeated authors) can pass the same byline row
+   * multiple times. We assign values by *iterating both `rows` and
+   * `summaries` in lockstep by index*, not by deduping into a Map keyed
+   * on byline id. A Map approach silently drops earlier duplicates' merge
+   * step (last writer wins, earlier instances keep their initial `{}`).
+   * Iterating by index gives every duplicate its own merged copy.
+   *
+   * Hydration is *strict per row* — values are merged onto whichever
+   * `BylineRow` produced them. Fallback semantics (e.g. "if no value
+   * for this locale, show the default-locale value") are not the
+   * repository's concern; consumers layer them on top if wanted, the
+   * same way `BylineRepository` doesn't resolve locale fallback for
+   * the base byline lookup.
+   */
+  private withCustomFields;
+  private withCustomFieldsOne;
+  /**
+   * Hydrate `customFields` on each `BylineSummary`, mutating in place.
+   *
+   * The public entry point for callers that fetch byline rows in
+   * multiple passes (e.g. `getBylinesForEntries`, which buckets by
+   * locale and calls `getContentBylinesMany` per bucket) and want a
+   * single batched hydration over the union of bylines, not one per
+   * pass. Use with the `skipHydration` option on the read methods to
+   * defer customFields work to a single call here.
+   *
+   * Two batched queries total (translatable + group-shared) regardless
+   * of how many bylines, locales, or translation_groups are in the
+   * input — meets the Phase 3 query-count envelope for mixed-locale
+   * list views even when sibling locales reference disjoint
+   * translation_groups.
+   *
+   * Replaces any existing `customFields` on each summary with a freshly
+   * fetched map. Callers that want to merge rather than replace should
+   * not use this entry point.
+   */
+  hydrateBylineCustomFields(summaries: BylineSummary[]): Promise<void>;
+  /**
+   * Shared merge engine for `withCustomFields` and
+   * `hydrateBylineCustomFields`. Reads field defs (cached), batches the
+   * translatable + group-shared fetches, and walks `summaries` directly
+   * to apply values.
+   *
+   * Iterates `summaries` (not a `summaryById` map) so duplicate
+   * `BylineSummary` objects sharing the same `id` — e.g. the same
+   * author credited to multiple entries — each get their own merged
+   * values. The previous Map-based dedup silently dropped earlier
+   * duplicates' merge step.
+   */
+  private applyCustomFieldsTo;
+  /**
+   * Resolve the group-shared custom-field values for a set of
+   * translation_groups, sharing work across hydration calls within the
+   * same request via per-group `requestCached` entries.
+   *
+   * The non-translatable storage table (`_emdash_byline_field_group_values`)
+   * is keyed by `translation_group`, which is locale-agnostic. Combining
+   * this method with `skipHydration` on `getContentBylinesMany` and a
+   * single `hydrateBylineCustomFields` call (see
+   * `getBylinesForEntries`) keeps mixed-locale list hydration to **one**
+   * batched group-shared SQL per request — even with disjoint
+   * translation_groups across locale buckets. Solo callers (`findById`,
+   * `findMany`, etc.) still get the same per-call batching they had
+   * before; the cache simply means a second call in the same request
+   * for an overlapping group is free.
+   *
+   * Cache key: `byline-field-group-values:${groupId}` — one entry per
+   * group. Writes use `setRequestCacheEntry` (idempotent, doesn't
+   * overwrite); `BylineRepository.update` calls `clearRequestCacheEntry`
+   * after a group-shared write to keep the cache fresh within the same
+   * request.
+   */
+  private loadGroupValuesByIds;
+  /**
+   * Every byline column plus the avatar's media columns, folded in by the
+   * same `LEFT JOIN media` the credit-hydration queries use. Only the
+   * single-row finders select this; `findMany` stays a single-table scan.
+   */
+  private selectBylineWithAvatar;
+  findById(id: string): Promise<BylineSummary | null>;
+  /**
+   * Find a byline by slug. When `locale` is provided, filter by it strictly.
+   * When omitted, returns the lowest-locale-code match (deterministic across
+   * calls). Mirrors `TaxonomyRepository.findBySlug`.
+   */
+  findBySlug(slug: string, options?: {
+    locale?: string;
+  }): Promise<BylineSummary | null>;
+  /**
+   * Find the byline linked to a CMS user. Post-migration 040 the partial
+   * unique on user_id is `(user_id, locale)`, so `locale` is required to
+   * disambiguate when multiple locale variants exist. When omitted, returns
+   * the lowest-locale-code match.
+   */
+  findByUserId(userId: string, options?: {
+    locale?: string;
+  }): Promise<BylineSummary | null>;
+  findMany(options?: {
+    search?: string;
+    isGuest?: boolean;
+    userId?: string;
+    locale?: string;
+    cursor?: string;
+    limit?: number;
+  }): Promise<FindManyResult<BylineSummary>>;
+  /**
+   * List every sibling row in `translation_group`. Used by the admin
+   * `TranslationsPanel` to render one entry per configured locale.
+   */
+  listTranslations(id: string): Promise<BylineSummary[]>;
+  /**
+   * Direct lookup by `translation_group`. Returns every locale variant of a
+   * byline, ordered by locale code (deterministic).
+   */
+  findByTranslationGroup(translationGroup: string): Promise<BylineSummary[]>;
+  /**
+   * Validate a `customFields` input map into a write list before any row
+   * write — throws `EmDashValidationError` on unknown slugs, type
+   * mismatches, or select-choice misses.
+   */
+  private resolveCustomFieldWrites;
+  /**
+   * Write a validated custom-field list against a byline row inside the
+   * caller's transaction. Per-field writes route to
+   * `_emdash_byline_field_values` (translatable) or
+   * `_emdash_byline_field_group_values` (group-shared); `null` clears.
+   * Returns `true` when any group-shared row was touched so the caller
+   * can invalidate the per-request cache post-commit.
+   */
+  private applyCustomFieldWritesInTrx;
+  create(input: CreateBylineInput): Promise<BylineSummary>;
+  update(id: string, input: UpdateBylineInput): Promise<BylineSummary | null>;
+  /**
+   * Delete a byline row. When this row is the last sibling in its
+   * translation group, also drops every junction row pointing at the group,
+   * clears `primary_byline_id` references, and removes the byline's
+   * non-translatable custom-field values. When other siblings remain in
+   * the group, junctions, `primary_byline_id` pointers, and group-shared
+   * custom-field values stay intact — the credit (and its shared metadata)
+   * lives on at other locales.
+   *
+   * **Application-level cascade.** The byline domain has standardised on
+   * app-level cascade rather than trusting FK ON DELETE CASCADE, partly
+   * because migration 040 had to strip its own FK to support the
+   * translation_group remap (#1021), and partly so cleanup doesn't
+   * depend on `PRAGMA foreign_keys = ON` (set in production via
+   * `connection.ts:60`, but easy to bypass in tests, scripts, and
+   * one-off tools). Every byline-related deletion table is cleared
+   * explicitly here:
+   *
+   * - `_emdash_byline_field_values` (per-byline translatable values) —
+   *   migration 041 declares FK ON DELETE CASCADE on `byline_id`; the
+   *   explicit DELETE removes the dependency on that pragma.
+   * - `_emdash_content_bylines` — migration 040 dropped its FK.
+   * - `ec_*.primary_byline_id` — never had an FK.
+   * - `_emdash_byline_field_group_values` (translation-group-keyed) —
+   *   keyed by a text column with no FK to bylines, so app-level cleanup
+   *   is the only path.
+   *
+   * The FKs that remain (migration 041) serve as defense-in-depth.
+   */
+  delete(id: string): Promise<boolean>;
+  /**
+   * Strict per-locale credit hydration. Joins `_emdash_content_bylines` to
+   * `_emdash_bylines` on `translation_group = byline_id`, then filters to
+   * the requested locale. Credits whose translation group lacks a row at
+   * the requested locale are omitted — callers wanting fallback behaviour
+   * apply it themselves. Mirrors `TaxonomyRepository.getTermsForEntry`.
+   */
+  getContentBylines(collectionSlug: string, contentId: string, options?: {
+    locale?: string;
+  }): Promise<ContentBylineCredit[]>;
+  /**
+   * Does this entry have any explicit byline credits — at any locale?
+   *
+   * Used to disambiguate "no credits exist" (fall back to author-linked
+   * byline) from "credits exist but don't resolve at the requested locale"
+   * (strict per-locale model: render no byline). Without this check the
+   * locale-strict hydration would silently turn a missing translation into
+   * an author-inferred byline, contradicting editorial intent.
+   */
+  hasContentBylines(collectionSlug: string, contentId: string): Promise<boolean>;
+  /**
+   * Batch variant of `hasContentBylines`. Returns the set of content IDs
+   * that have at least one junction row (locale-agnostic).
+   */
+  hasContentBylinesMany(collectionSlug: string, contentIds: string[]): Promise<Set<string>>;
+  /**
+   * Batch variant of `getContentBylines`. Same strict-per-locale semantics
+   * applied to the requested locale (single value, not per-entry).
+   *
+   * When callers need per-entry-locale filtering (e.g. a list endpoint
+   * returning entries at mixed locales), they should group the input ids by
+   * the entry's locale and call this method once per group.
+   *
+   * When the caller will issue multiple `getContentBylinesMany` calls in
+   * one request (e.g. per locale bucket) and wants a *single* batched
+   * customFields hydration over the union of returned bylines, pass
+   * `skipHydration: true` on each call and finish with
+   * `hydrateBylineCustomFields(allBylines)`. The returned bylines carry
+   * `customFields = {}` until that hydration call runs — matching the
+   * "always populated" invariant from AC #6 — so callers that forget to
+   * hydrate get an empty map rather than `undefined`.
+   */
+  getContentBylinesMany(collectionSlug: string, contentIds: string[], options?: {
+    locale?: string;
+    skipHydration?: boolean;
+  }): Promise<Map<string, ContentBylineCredit[]>>;
+  /**
+   * Batch-fetch byline profiles linked to user IDs in a single query.
+   * Strict-locale variant of `findByUserId`.
+   *
+   * `skipHydration: true` returns bylines with `customFields = {}` so
+   * callers issuing multiple `findByUserIds` calls in one request (e.g.
+   * the per-locale-bucket author-fallback path in `getBylinesForEntries`)
+   * can defer customFields hydration to a single batched
+   * `hydrateBylineCustomFields` call across the union — keeping the
+   * Phase 3 query-count envelope at "+1 group-shared query per
+   * hydration pass" even when buckets fetch disjoint author bylines.
+   */
+  findByUserIds(userIds: string[], options?: {
+    locale?: string;
+    skipHydration?: boolean;
+  }): Promise<Map<string, BylineSummary>>;
+  /**
+   * Clone every junction row from `sourceContentId` to `targetContentId`,
+   * preserving `sort_order` and `role_label`. Used by the content
+   * translation flow: a newly created translation inherits the source's
+   * byline credits at the storage level. Because the junction stores
+   * `translation_group` (not a row id), the copy is locale-agnostic — the
+   * credits resolve to whichever locale variants of each byline exist when
+   * the translated entry is hydrated.
+   *
+   * No-op when the source has no credits. Skips when the target already
+   * has credits (idempotent for re-runs).
+   */
+  copyContentBylines(collection: string, sourceContentId: string, targetContentId: string): Promise<void>;
+  /**
+   * Replace the set of byline credits on a content entry. Accepts row ids
+   * at the wire (consistent with how the admin sends them), translates
+   * each to its `translation_group` on write, and stores the group in
+   * `_emdash_content_bylines.byline_id` and `ec_*.primary_byline_id`.
+   *
+   * The returned credits are hydrated with strict-locale matching at the
+   * locale of the rows the caller supplied (i.e. the locale of the byline
+   * each `bylineId` resolves to) — adequate for the autosave round-trip,
+   * which then re-hydrates the entry against its own locale separately.
+   */
+  setContentBylines(collectionSlug: string, contentId: string, inputBylines: ContentBylineInput[]): Promise<ContentBylineCredit[]>;
+  deleteContentBylines(collectionSlug: string, contentId: string): Promise<number>;
+}
+//#endregion
+//#region src/utils/slugify.d.ts
+/**
+ * Decode a URI-encoded slug parameter.
+ *
+ * Browsers percent-encode non-ASCII characters in URLs, so a slug like
+ * "మేష-రాసి" arrives as "%e0%b0%ae%e0%b1%87%e0%b0%b7-%e0%b0%b0%e0%b0%be%e0%b0%b8%e0%b0%bf".
+ * Call this on `Astro.params.slug` before using it in database lookups.
+ */
+declare function decodeSlug(raw: string | undefined): string | undefined;
+//#endregion
+//#region src/import/utils.d.ts
+/** Turn a WordPress post type name into a valid, non-reserved collection slug. */
+declare function sanitizeCollectionSlug(slug: string): string;
+/**
+ * Map WordPress post type to EmDash collection name
+ */
+declare function mapPostTypeToCollection(postType: string): string;
+//#endregion
+export { BylineRepository as a, slugify as i, sanitizeCollectionSlug as n, ContentBylineInput as o, decodeSlug as r, mapPostTypeToCollection as t };
+//# sourceMappingURL=utils-Szp4iBQB.d.mts.map

package/dist/utils-Szp4iBQB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-Szp4iBQB.d.mts","names":[],"sources":["../src/database/repositories/byline.ts","../src/utils/slugify.ts","../src/import/utils.ts"],"mappings":"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"}