@orthacms/content-server 0.0.0-reserve.0

package/dist/lib/insights/infrastructure/queries/content-insights.query.js

@@ -0,0 +1,380 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentInsightsQuery = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const drizzle_orm_1 = require("drizzle-orm");
+const database_1 = require("@orthacms/database");
+const content_tokens_1 = require("../../../content.tokens");
+const content_type_1 = require("../../../types/content-type");
+const revision_table_1 = require("../../../revisions/infrastructure/persistence/revision-table");
+/** Age boundaries (in days) of the staleness breakdown, freshest first. */
+const STALE_BOUNDS = [
+    { id: 'd30', upTo: 30 },
+    { id: 'd90', upTo: 90 },
+    { id: 'd180', upTo: 180 },
+    { id: 'd365', upTo: 365 }
+];
+/** Sparkline points on the stat tiles — enough to read a shape, no axis. */
+const HISTORY_POINTS = 8;
+/** Reads a generated table's columns by property name. */
+function columnsOf(type) {
+    return type.table;
+}
+/**
+ * Picks a bucket width for a window.
+ *
+ * Bounded so a series never returns hundreds of points: a 12-month range grouped
+ * by day would be 365 buckets for a sparkline that is 64 pixels wide.
+ */
+function granularityFor(days) {
+    if (days <= 31)
+        return 'day';
+    if (days <= 120)
+        return 'week';
+    return 'month';
+}
+/**
+ * The bucket unit as a SQL **literal**, never a bound parameter.
+ *
+ * This looks like a pointless detour and is load-bearing. Drizzle re-renders a
+ * reused `sql` fragment at each call site, so `date_trunc(${granularity}, …)`
+ * becomes `$1` in the SELECT and `$4` in the GROUP BY — Postgres then sees two
+ * different expressions and rejects the query with "column must appear in the
+ * GROUP BY clause". Emitting the unit inline makes the two textually identical,
+ * which is what lets it match.
+ *
+ * Safe to inline because it is not caller data: `Granularity` is a closed union
+ * produced only by {@link granularityFor} from a bounded number, and the switch
+ * below maps it to a fixed literal rather than interpolating the variable.
+ */
+function truncUnit(granularity) {
+    switch (granularity) {
+        case 'day':
+            return (0, drizzle_orm_1.sql) `'day'`;
+        case 'week':
+            return (0, drizzle_orm_1.sql) `'week'`;
+        case 'month':
+            return (0, drizzle_orm_1.sql) `'month'`;
+    }
+}
+/** The instant a window of `days` starts, relative to now. */
+function windowStart(days) {
+    const start = new Date();
+    start.setUTCDate(start.getUTCDate() - days);
+    return start;
+}
+/**
+ * Live read-model for the content Insights widgets.
+ *
+ * Every figure is aggregated **on demand** from the collection tables rather
+ * than folded into a projection. That is a deliberate trade for this stage: the
+ * counts are workspace-scoped and hit the existing
+ * `(workspace_id, …)` list indexes, so they are cheap at the scale a single
+ * workspace's content reaches, and a projection would add a table, migrations
+ * and a rebuild path to maintain before anything proved it was needed. The seam
+ * to change later is this class alone — the HTTP contract and the widgets don't
+ * know where the numbers come from.
+ *
+ * Each method queries **per content type** and merges in memory. There is no
+ * single table to group over: a collection is its own generated
+ * `content_<name>` table, so "entries in this workspace" is inherently a fan-out.
+ */
+let ContentInsightsQuery = class ContentInsightsQuery {
+    db;
+    registry;
+    constructor(db, registry) {
+        this.db = db;
+        this.registry = registry;
+    }
+    /**
+     * Restricts a read to one workspace, and to rows that still exist.
+     *
+     * The soft-delete clause is why this is shared rather than inlined: a
+     * tombstoned entry is still a row, and a count that forgets `deleted_at`
+     * silently reports deleted content as live — the kind of wrong number a
+     * dashboard is believed on.
+     */
+    scope(type, workspaceId) {
+        const columns = columnsOf(type);
+        return (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(columns['workspaceId'], workspaceId), type.paranoid ? (0, drizzle_orm_1.isNull)(columns['deletedAt']) : undefined);
+    }
+    /** Counts rows of one type matching an extra predicate. */
+    async countOf(type, workspaceId, extra) {
+        const [row] = await this.db
+            .select({ n: (0, drizzle_orm_1.sql) `cast(count(*) as int)` })
+            .from(type.table)
+            .where((0, drizzle_orm_1.and)(this.scope(type, workspaceId), extra));
+        return row?.n ?? 0;
+    }
+    /**
+     * Counts rows per time bucket over a window, for one type and one
+     * timestamp column. Returns raw buckets — the caller decides whether they
+     * are a series or the increments of a cumulative total.
+     */
+    async bucketed(type, workspaceId, column, days, granularity) {
+        const truncated = (0, drizzle_orm_1.sql) `date_trunc(${truncUnit(granularity)}, ${column})`;
+        const rows = await this.db
+            .select({
+            bucket: (0, drizzle_orm_1.sql) `to_char(${truncated}, 'YYYY-MM-DD')`,
+            n: (0, drizzle_orm_1.sql) `cast(count(*) as int)`
+        })
+            .from(type.table)
+            .where((0, drizzle_orm_1.and)(this.scope(type, workspaceId), (0, drizzle_orm_1.sql) `${column} >= ${windowStart(days)}`))
+            .groupBy(truncated);
+        return new Map(rows.map((row) => [row.bucket, row.n]));
+    }
+    /** Headline counts, deltas and sparkline history for the stat tiles. */
+    async totals(workspaceId, days) {
+        const types = this.registry.all();
+        const granularity = granularityFor(days);
+        let entries = 0;
+        let published = 0;
+        let drafts = 0;
+        const createdBuckets = new Map();
+        const publishedBuckets = new Map();
+        for (const type of types) {
+            const columns = columnsOf(type);
+            entries += await this.countOf(type, workspaceId);
+            // A non-publishable type has no draft stage at all — every row is
+            // live. Counting it as "published" is the honest reading; treating
+            // it as neither would make the two tiles fail to add up to the total.
+            if (type.publishable) {
+                published += await this.countOf(type, workspaceId, (0, drizzle_orm_1.eq)(columns['status'], content_type_1.ENTRY_STATUS.Published));
+                drafts += await this.countOf(type, workspaceId, (0, drizzle_orm_1.eq)(columns['status'], content_type_1.ENTRY_STATUS.Draft));
+                mergeBuckets(publishedBuckets, await this.bucketed(type, workspaceId, columns['publishedAt'], days, granularity));
+            }
+            else {
+                published += await this.countOf(type, workspaceId);
+            }
+            mergeBuckets(createdBuckets, await this.bucketed(type, workspaceId, columns['createdAt'], days, granularity));
+        }
+        const entriesDelta = sumOf(createdBuckets);
+        const publishedDelta = sumOf(publishedBuckets);
+        return {
+            entries,
+            published,
+            drafts,
+            entriesDelta,
+            publishedDelta,
+            entriesHistory: cumulativeFrom(entries - entriesDelta, createdBuckets),
+            publishedHistory: cumulativeFrom(published - publishedDelta, publishedBuckets)
+        };
+    }
+    /** Published entries grouped by how long ago they were last edited. */
+    async stale(workspaceId) {
+        const counts = new Map(STALE_BOUNDS.map((bound) => [bound.id, 0]));
+        counts.set('older', 0);
+        for (const type of this.registry.all()) {
+            const columns = columnsOf(type);
+            const updatedAt = columns['updatedAt'];
+            // Only live content can be "stale" — an untouched draft is a draft,
+            // not a neglected published page, and mixing them would inflate
+            // every bucket with work that was never finished in the first place.
+            const liveOnly = type.publishable
+                ? (0, drizzle_orm_1.eq)(columns['status'], content_type_1.ENTRY_STATUS.Published)
+                : undefined;
+            const [row] = await this.db
+                .select({
+                d30: bucketExpression(updatedAt, 0, 30),
+                d90: bucketExpression(updatedAt, 30, 90),
+                d180: bucketExpression(updatedAt, 90, 180),
+                d365: bucketExpression(updatedAt, 180, 365),
+                older: (0, drizzle_orm_1.sql) `cast(count(*) filter (
+                        where ${updatedAt} < now() - make_interval(days => 365)
+                    ) as int)`
+            })
+                .from(type.table)
+                .where((0, drizzle_orm_1.and)(this.scope(type, workspaceId), liveOnly));
+            if (!row)
+                continue;
+            for (const key of [
+                'd30',
+                'd90',
+                'd180',
+                'd365',
+                'older'
+            ]) {
+                counts.set(key, (counts.get(key) ?? 0) + (row[key] ?? 0));
+            }
+        }
+        const buckets = [...STALE_BOUNDS.map((b) => b.id), 'older'].map((id) => ({ id, count: counts.get(id) ?? 0 }));
+        return {
+            buckets,
+            total: buckets.reduce((sum, bucket) => sum + bucket.count, 0)
+        };
+    }
+    /** Draft/published split per content type. */
+    async pipeline(workspaceId) {
+        const types = [];
+        for (const type of this.registry.all()) {
+            const columns = columnsOf(type);
+            const published = type.publishable
+                ? await this.countOf(type, workspaceId, (0, drizzle_orm_1.eq)(columns['status'], content_type_1.ENTRY_STATUS.Published))
+                : await this.countOf(type, workspaceId);
+            const drafts = type.publishable
+                ? await this.countOf(type, workspaceId, (0, drizzle_orm_1.eq)(columns['status'], content_type_1.ENTRY_STATUS.Draft))
+                : 0;
+            // A type the workspace has never used is noise on a chart about
+            // where the workspace's weight sits.
+            if (published + drafts === 0)
+                continue;
+            types.push({
+                name: type.name,
+                label: type.label,
+                published,
+                drafts
+            });
+        }
+        types.sort((a, b) => b.published + b.drafts - (a.published + a.drafts));
+        return { types };
+    }
+    /**
+     * Live content carrying unpublished edits, per type and in total.
+     *
+     * The three figures come out of **one** grouped query per type rather than
+     * three `countOf` calls, because they partition the same rows: a scan that
+     * has already found a row can decide which of the three it belongs to.
+     *
+     * A **non-publishable** type contributes nothing at all — not even to
+     * `live`. It has no draft stage, so every row is trivially current, and
+     * folding those rows into the denominator would make "3 of 900 live records
+     * have pending edits" a number about a workspace's always-live singletons
+     * rather than about anything an editor can ship.
+     */
+    async unshipped(workspaceId) {
+        const types = [];
+        let modified = 0;
+        let live = 0;
+        let neverPublished = 0;
+        for (const type of this.registry.all()) {
+            if (!type.publishable)
+                continue;
+            const columns = columnsOf(type);
+            const status = columns['status'];
+            const publishedAt = columns['publishedAt'];
+            const [row] = await this.db
+                .select({
+                modified: (0, drizzle_orm_1.sql) `cast(count(*) filter (
+                        where ${status} = ${content_type_1.ENTRY_STATUS.Draft}
+                          and ${publishedAt} is not null
+                    ) as int)`,
+                published: (0, drizzle_orm_1.sql) `cast(count(*) filter (
+                        where ${status} = ${content_type_1.ENTRY_STATUS.Published}
+                    ) as int)`,
+                neverPublished: (0, drizzle_orm_1.sql) `cast(count(*) filter (
+                        where ${status} = ${content_type_1.ENTRY_STATUS.Draft}
+                          and ${publishedAt} is null
+                    ) as int)`
+            })
+                .from(type.table)
+                .where(this.scope(type, workspaceId));
+            if (!row)
+                continue;
+            modified += row.modified;
+            live += row.modified + row.published;
+            neverPublished += row.neverPublished;
+            // A type with nothing pending is not a row on a chart about what is
+            // pending — it would be a permanently empty bar diluting the ones
+            // that mean something.
+            if (row.modified === 0)
+                continue;
+            types.push({
+                name: type.name,
+                label: type.label,
+                modified: row.modified,
+                published: row.published
+            });
+        }
+        types.sort((a, b) => b.modified - a.modified);
+        return { types, modified, live, neverPublished };
+    }
+    /** Entries published per time bucket across the window. */
+    async velocity(workspaceId, days) {
+        const granularity = granularityFor(days);
+        const merged = new Map();
+        for (const type of this.registry.all()) {
+            if (!type.publishable)
+                continue;
+            mergeBuckets(merged, await this.bucketed(type, workspaceId, columnsOf(type)['publishedAt'], days, granularity));
+        }
+        return { points: toSeries(merged), granularity };
+    }
+    /**
+     * Editing activity by weekday and hour, from the revision store.
+     *
+     * The one content figure that is a single grouped query rather than a
+     * fan-out: `content_entry_revisions` is generic across every type, so the
+     * whole workspace's editing history lives in one table.
+     *
+     * Hours come out in the database session's timezone (UTC in every
+     * deployment we run). Rendering them as local time would need each
+     * viewer's offset applied to the grouping, not to the labels — shifting
+     * the labels alone would silently mislabel the buckets.
+     */
+    async punchcard(workspaceId, days) {
+        const rows = await this.db
+            .select({
+            weekday: (0, drizzle_orm_1.sql) `cast(extract(isodow from ${revision_table_1.contentEntryRevisions.createdAt}) as int)`,
+            hour: (0, drizzle_orm_1.sql) `cast(extract(hour from ${revision_table_1.contentEntryRevisions.createdAt}) as int)`,
+            count: (0, drizzle_orm_1.sql) `cast(count(*) as int)`
+        })
+            .from(revision_table_1.contentEntryRevisions)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(revision_table_1.contentEntryRevisions.workspaceId, workspaceId), (0, drizzle_orm_1.sql) `${revision_table_1.contentEntryRevisions.createdAt} >= ${windowStart(days)}`))
+            .groupBy((0, drizzle_orm_1.sql) `extract(isodow from ${revision_table_1.contentEntryRevisions.createdAt})`, (0, drizzle_orm_1.sql) `extract(hour from ${revision_table_1.contentEntryRevisions.createdAt})`);
+        return {
+            cells: rows,
+            max: rows.reduce((peak, row) => Math.max(peak, row.count), 0),
+            total: rows.reduce((sum, row) => sum + row.count, 0)
+        };
+    }
+};
+exports.ContentInsightsQuery = ContentInsightsQuery;
+exports.ContentInsightsQuery = ContentInsightsQuery = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, database_1.InjectDatabase)()),
+    tslib_1.__param(1, (0, content_tokens_1.InjectContentRegistry)()),
+    tslib_1.__metadata("design:paramtypes", [Object, Function])
+], ContentInsightsQuery);
+/** Counts rows whose timestamp falls in a half-open age window, in days. */
+function bucketExpression(column, fromDays, toDays) {
+    return (0, drizzle_orm_1.sql) `cast(count(*) filter (
+        where ${column} <= now() - make_interval(days => ${fromDays})
+          and ${column} > now() - make_interval(days => ${toDays})
+    ) as int)`;
+}
+/** Adds one type's bucket counts into a running total across types. */
+function mergeBuckets(into, from) {
+    for (const [bucket, value] of from) {
+        into.set(bucket, (into.get(bucket) ?? 0) + value);
+    }
+}
+/** Sums every bucket. */
+function sumOf(buckets) {
+    let total = 0;
+    for (const value of buckets.values())
+        total += value;
+    return total;
+}
+/** Sorts a bucket map into an ascending series. */
+function toSeries(buckets) {
+    return [...buckets.entries()]
+        .map(([bucket, value]) => ({ bucket, value }))
+        .sort((a, b) => a.bucket.localeCompare(b.bucket));
+}
+/**
+ * Turns per-bucket increments into a running total, starting from the count as
+ * it stood before the window opened.
+ *
+ * Trimmed to the last {@link HISTORY_POINTS} so a sparkline gets a readable
+ * number of points regardless of the selected range.
+ */
+function cumulativeFrom(baseline, buckets) {
+    const series = toSeries(buckets);
+    let running = Math.max(0, baseline);
+    const history = series.map((point) => {
+        running += point.value;
+        return running;
+    });
+    return history.slice(-HISTORY_POINTS);
+}

package/dist/lib/insights/types/content-insights-view.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Read-side view shapes for the content Insights widgets.
+ *
+ * These are **transport contracts**, restated verbatim by `content-admin` (the
+ * admin can't import a server package across the module boundary). Every one is
+ * derived live from the collection tables — this plugin keeps no projection and
+ * owns no insights schema.
+ */
+/** A single point on a time series. */
+export interface InsightsSeriesPoint {
+    /** Bucket start, `YYYY-MM-DD`. The client formats it. */
+    bucket: string;
+    /** Measured value for the bucket. */
+    value: number;
+}
+/**
+ * Headline counts for the stat tiles.
+ *
+ * `draftsDelta` is deliberately absent while `entriesDelta` and `publishedDelta`
+ * are present. A draft's count changes when a row is *published*, and nothing
+ * records when that transition happened in reverse — `published_at` tells us
+ * when something went live, but a row that moved back to draft leaves no trace
+ * on the collection table. Reporting a draft delta would mean inventing one.
+ */
+export interface ContentTotalsView {
+    /** Every non-deleted entry in the workspace. */
+    entries: number;
+    /** Entries currently live. */
+    published: number;
+    /** Entries currently in draft. */
+    drafts: number;
+    /** Entries created within the window. */
+    entriesDelta: number;
+    /** Entries first published within the window. */
+    publishedDelta: number;
+    /** Cumulative entry count across the window, oldest bucket first. */
+    entriesHistory: number[];
+    /** Cumulative published count across the window, oldest bucket first. */
+    publishedHistory: number[];
+}
+/** One age bucket of the staleness breakdown. */
+export interface StaleBucketView {
+    /** Bucket key — `d30`, `d90`, `d180`, `d365`, `older`. */
+    id: string;
+    /** Entries whose last edit falls in this bucket. */
+    count: number;
+}
+/** Published entries grouped by how long ago they were last touched. */
+export interface ContentStaleView {
+    /** The buckets, freshest first. */
+    buckets: StaleBucketView[];
+    /** Total across all buckets, so the client needn't re-add them. */
+    total: number;
+}
+/** Draft/published split for one content type. */
+export interface PipelineTypeView {
+    /** The type's machine name. */
+    name: string;
+    /** Its human label. */
+    label: string;
+    /** Entries currently live. */
+    published: number;
+    /** Entries currently in draft. */
+    drafts: number;
+}
+/** Draft/published split across every content type in the workspace. */
+export interface ContentPipelineView {
+    /** One row per type that has at least one entry, biggest first. */
+    types: PipelineTypeView[];
+}
+/** Entries published per time bucket. */
+export interface ContentVelocityView {
+    /** The series, oldest bucket first. */
+    points: InsightsSeriesPoint[];
+    /** Bucket width, so the client can label the axis correctly. */
+    granularity: 'day' | 'week' | 'month';
+}
+/** Live-vs-unpublished-edits split for one content type. */
+export interface UnshippedTypeView {
+    /** The type's machine name. */
+    name: string;
+    /** Its human label. */
+    label: string;
+    /** Entries live with unpublished edits on top of what is live. */
+    modified: number;
+    /** Entries live and current — nothing pending. */
+    published: number;
+}
+/**
+ * Entries whose live version is behind what an editor has saved.
+ *
+ * The publish state is **two stored values that carry three meanings**, which is
+ * the whole reason this endpoint exists: `status` alone cannot separate "never
+ * published" from "published, then edited". `published_at` is stamped on the
+ * first publish and cleared only by an unpublish, so `draft` + a timestamp is
+ * live content with unpublished changes on top — the admin's **Modified** badge
+ * — while `draft` + no timestamp is a draft nobody has ever shipped.
+ */
+export interface ContentUnshippedView {
+    /** One row per publishable type holding at least one modified entry. */
+    types: UnshippedTypeView[];
+    /** Modified entries across the workspace — live, with edits pending. */
+    modified: number;
+    /** Entries with a live version at all (`modified` + fully published). */
+    live: number;
+    /** Drafts that have never gone live. */
+    neverPublished: number;
+}
+/** One weekday × hour cell of the editing punchcard. */
+export interface PunchcardCellView {
+    /** ISO weekday, 1 = Monday … 7 = Sunday. */
+    weekday: number;
+    /** Hour of day, 0–23, in the database session's timezone (UTC). */
+    hour: number;
+    /** Revisions written in that slot. */
+    count: number;
+}
+/**
+ * Editing activity by weekday and hour.
+ *
+ * Only non-empty slots are returned — a full 7 × 24 grid is 168 cells and most
+ * are zero, so the client fills the gaps. `max` comes with it because the client
+ * needs the busiest value to normalise the ramp, and recomputing it from a
+ * sparse list would give the wrong denominator whenever the grid is empty.
+ */
+export interface ContentPunchcardView {
+    /** The non-empty cells. */
+    cells: PunchcardCellView[];
+    /** The busiest cell's count, or 0 when there is no activity. */
+    max: number;
+    /** Revisions across the whole window. */
+    total: number;
+}
+//# sourceMappingURL=content-insights-view.d.ts.map

package/dist/lib/insights/types/content-insights-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-insights-view.d.ts","sourceRoot":"","sources":["../../../../src/lib/insights/types/content-insights-view.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,uCAAuC;AACvC,MAAM,WAAW,mBAAmB;IAChC,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,KAAK,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IAC9B,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,YAAY,EAAE,MAAM,CAAC;IACrB,iDAAiD;IACjD,cAAc,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,yEAAyE;IACzE,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,iDAAiD;AACjD,MAAM,WAAW,eAAe;IAC5B,0DAA0D;IAC1D,EAAE,EAAE,MAAM,CAAC;IACX,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,wEAAwE;AACxE,MAAM,WAAW,gBAAgB;IAC7B,mCAAmC;IACnC,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,kDAAkD;AAClD,MAAM,WAAW,gBAAgB;IAC7B,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,wEAAwE;AACxE,MAAM,WAAW,mBAAmB;IAChC,mEAAmE;IACnE,KAAK,EAAE,gBAAgB,EAAE,CAAC;CAC7B;AAED,yCAAyC;AACzC,MAAM,WAAW,mBAAmB;IAChC,uCAAuC;IACvC,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC9B,gEAAgE;IAChE,WAAW,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;CACzC;AAED,4DAA4D;AAC5D,MAAM,WAAW,iBAAiB;IAC9B,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,oBAAoB;IACjC,wEAAwE;IACxE,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,cAAc,EAAE,MAAM,CAAC;CAC1B;AAED,wDAAwD;AACxD,MAAM,WAAW,iBAAiB;IAC9B,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACjC,2BAA2B;IAC3B,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,gEAAgE;IAChE,GAAG,EAAE,MAAM,CAAC;IACZ,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;CACjB"}

package/dist/lib/insights/types/content-insights-view.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Read-side view shapes for the content Insights widgets.
+ *
+ * These are **transport contracts**, restated verbatim by `content-admin` (the
+ * admin can't import a server package across the module boundary). Every one is
+ * derived live from the collection tables — this plugin keeps no projection and
+ * owns no insights schema.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/mcp/content-tools.provider.d.ts

@@ -0,0 +1,83 @@
+import { OnModuleInit } from '@nestjs/common';
+import { ToolRegistry, type ResourceContents, type ResourceDefinition, type ToolContext, type ToolDefinition, type ToolProvider } from '@orthacms/tools-server';
+import type { ContentTypeRegistry } from '../registry/content-type-registry';
+import { WorkspaceGrantsQuery } from '../content-types/queries/workspace-grants.query';
+import { PublicEntriesQuery } from '../public-api/infrastructure/public-entries.query';
+import { PublicEntryWritesService } from '../public-api/infrastructure/public-entry-writes.service';
+/**
+ * The content plugin's contribution to the shared agent tool registry — the
+ * same CRUD the public HTTP API serves, reachable by an MCP client or the
+ * copilot's tool loop.
+ *
+ * **Every handler delegates to the objects the HTTP controllers call**:
+ * `resolveGrantedType` for the grant gate, `PublicEntriesQuery` for reads,
+ * `PublicEntryWritesService` for writes. That is the whole design. The rules
+ * that make the public API safe — published-only by default, soft-deleted rows
+ * invisible, an ungranted type indistinguishable from an unknown one, relations
+ * that may not cross locales, validation at publish time, revision numbering
+ * under an advisory lock, the outbox — are not restated here and therefore
+ * cannot drift from the HTTP surface. This class contributes the tool
+ * descriptions, argument validation, and the mapping from arguments to those
+ * calls, and nothing else.
+ *
+ * **Authorization is declared, not implemented.** Each tool names the
+ * permissions it needs in `requires`, and `ToolRegistry.call` enforces them
+ * before dispatch — the analogue of `@RequirePermissions(...)` on a route. A
+ * `read`-scoped token cannot reach a write tool, and no handler below contains
+ * a line of code saying so. The one authorization decision a handler *does*
+ * make is the draft-visibility widening, because it is a rule about an argument
+ * rather than about the operation.
+ *
+ * Registration is `@Optional()`: MCP is a plugin, so a deployment that omits it
+ * must still boot. The tools simply go unregistered.
+ */
+export declare class ContentToolProvider implements ToolProvider, OnModuleInit {
+    private readonly registry;
+    private readonly grants;
+    private readonly entries;
+    private readonly writes;
+    private readonly toolRegistry?;
+    constructor(registry: ContentTypeRegistry, grants: WorkspaceGrantsQuery, entries: PublicEntriesQuery, writes: PublicEntryWritesService, toolRegistry?: ToolRegistry | undefined);
+    /**
+     * Register with the tool registry once the DI graph is built. A call rather
+     * than a DI binding because Nest has no multi-provider token — see
+     * `ToolProvider`.
+     */
+    onModuleInit(): void;
+    /**
+     * The sixteen content tools. @see ToolProvider.tools
+     *
+     * Every one is stamped `surfaces: ['mcp']` below rather than tool by tool:
+     * they are uniformly the **public-API** set — published-only reads through
+     * `PublicEntriesQuery`, writes through `PublicEntryWritesService` attributed
+     * to a token. The copilot's content tools are the admin-scoped counterpart
+     * (a viewer must see drafts; a write records the accepting human), so the
+     * two sets share the registry and not each other's callers.
+     */
+    tools(): readonly ToolDefinition[];
+    /** The tool definitions themselves, before the surface stamp. */
+    private mcpTools;
+    /**
+     * Each readable content type as a resource, so a client that supports them
+     * can pull a schema into context without spending a tool call. Pruned to
+     * the workspace's grants, exactly like `content_types_list`.
+     */
+    resources(context: ToolContext): Promise<readonly ResourceDefinition[]>;
+    /** @see ToolProvider.readResource */
+    readResource(uri: string, context: ToolContext): Promise<ResourceContents | undefined>;
+    /** The workspace's granted type summaries. */
+    private grantedSummaries;
+    /** Resolve a type through the shared registry + grant gate. */
+    private resolve;
+    /**
+     * One type's serialized schema, plus a JSON Schema for its `values` bag.
+     *
+     * Both, because they answer different questions: the serialized fields
+     * carry the CMS's own vocabulary (which field is a relation, what a select's
+     * options are), while the JSON Schema is what a model needs to construct a
+     * valid `values` object. `fieldSchema` is the same generator the OpenAPI
+     * document uses, so the two descriptions of a type cannot disagree.
+     */
+    private describeType;
+}
+//# sourceMappingURL=content-tools.provider.d.ts.map

package/dist/lib/mcp/content-tools.provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-tools.provider.d.ts","sourceRoot":"","sources":["../../../src/lib/mcp/content-tools.provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,YAAY,EAEf,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACH,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,YAAY,EACpB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EACR,mBAAmB,EAEtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,iDAAiD,CAAC;AAEvF,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AACvF,OAAO,EAAE,wBAAwB,EAAE,MAAM,0DAA0D,CAAC;AAoCpG;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBACa,mBAAoB,YAAW,YAAY,EAAE,YAAY;IAG9D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACX,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;gBAJzB,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,oBAAoB,EAC5B,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,wBAAwB,EACpB,YAAY,CAAC,EAAE,YAAY,YAAA;IAG5D;;;;OAIG;IACH,YAAY,IAAI,IAAI;IAIpB;;;;;;;;;OASG;IACH,KAAK,IAAI,SAAS,cAAc,EAAE;IAOlC,iEAAiE;IACjE,OAAO,CAAC,QAAQ;IA6ZhB;;;;OAIG;IACG,SAAS,CACX,OAAO,EAAE,WAAW,GACrB,OAAO,CAAC,SAAS,kBAAkB,EAAE,CAAC;IAUzC,qCAAqC;IAC/B,YAAY,CACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,WAAW,GACrB,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAgBxC,8CAA8C;YAChC,gBAAgB;IAO9B,+DAA+D;IAC/D,OAAO,CAAC,OAAO;IASf;;;;;;;;OAQG;IACH,OAAO,CAAC,YAAY;CA6BvB"}