@orthacms/content-server 0.0.0-reserve.0

package/dist/lib/mcp/tool-schemas.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BULK_IDS_SCHEMA = exports.BULK_SAVE_SCHEMA = exports.ENTRY_ACTION_SCHEMA = exports.UPDATE_SCHEMA = exports.CREATE_SCHEMA = exports.TRANSLATIONS_SCHEMA = exports.MEDIA_SCHEMA = exports.RELATIONS_SCHEMA = exports.GET_ENTRY_SCHEMA = exports.LIST_ENTRIES_SCHEMA = exports.GET_TYPE_SCHEMA = exports.LIST_TYPES_SCHEMA = void 0;
+const entries_constants_1 = require("../entries/entries.constants");
+const public_list_entries_query_dto_1 = require("../public-api/http/dto/public-list-entries-query.dto");
+/**
+ * JSON Schemas for the content tools' arguments.
+ *
+ * **Hand-written and generic**, not generated per content type — the single
+ * most consequential shape decision in this surface. An MCP client loads every
+ * tool's schema into the model's context on connect, so generating
+ * `article_create`, `author_create`, `tag_create`… would put the entire content
+ * model in the prompt of every conversation and scale the cost with the number
+ * of collections. It could not even be a fixed set: the visible types depend on
+ * the calling token's workspace grants.
+ *
+ * So the tools take `typeName` as an argument, exactly as the HTTP routes take
+ * it as a path segment, and a model **discovers** the shape it needs with
+ * `content_type_get` — one type, on demand. That is why every `values`
+ * parameter below is an open object whose description points at the discovery
+ * tool rather than an inline schema.
+ *
+ * These are the schemas for the *arguments*; the per-type field schemas
+ * `content_type_get` returns are generated from the registry by
+ * `docs/field-schema.ts`, which already produces them for the OpenAPI document.
+ */
+/** `typeName`, on every tool. */
+const TYPE_NAME = {
+    type: 'string',
+    description: 'Machine name of the content type, e.g. `article`. Call `content_types_list` for the names this workspace exposes.'
+};
+/** The two ways to name one entry. */
+const LOCATOR = {
+    id: {
+        type: 'string',
+        format: 'uuid',
+        description: 'The entry id. Pass this **or** `localeGroupId`, not both.'
+    },
+    localeGroupId: {
+        type: 'string',
+        format: 'uuid',
+        description: 'The entry’s translation group id, resolved together with `locale`. Use this when you track a record across languages — the group id is stable, each locale’s `id` is not.'
+    }
+};
+/** `locale`, wherever a localized type can be addressed. */
+const LOCALE = {
+    type: 'string',
+    maxLength: 35,
+    description: 'Locale slug (e.g. `en`). Absent means the default locale. Ignored on types that are not localized.'
+};
+/** The publish-state filter, gated on write scope for anything but the default. */
+const STATUS = {
+    type: 'string',
+    enum: [...public_list_entries_query_dto_1.ENTRY_VISIBILITY],
+    description: 'Publish states to return. `published` (the default) is all a read-only token may ask for; `draft` and `any` need write scope. Use `any` after creating an entry — a new entry is a draft and the default would not find it.'
+};
+/** Sparse fieldsets — the main lever on how much context a result costs. */
+const FIELDS = {
+    type: 'string',
+    description: 'Comma-separated field names to return in `values`, e.g. `title,slug`. Absent returns every field, which on a type with rich text can be very large — prefer naming the fields you need.'
+};
+/** Relation/media/translation expansion, shared by the single-entry reads. */
+const EXPANSIONS = {
+    relations: {
+        type: 'string',
+        enum: ['preview'],
+        description: 'Set to `preview` to expand the relation fields named in `relationFields`.'
+    },
+    relationFields: {
+        type: 'string',
+        description: 'Comma-separated relation fields to expand, e.g. `author,tags`. Ignored without `relations=preview`.'
+    },
+    media: {
+        type: 'string',
+        enum: ['preview'],
+        description: 'Set to `preview` to expand the media fields named in `mediaFields`.'
+    },
+    mediaFields: {
+        type: 'string',
+        description: 'Comma-separated media fields to expand. Ignored without `media=preview`.'
+    },
+    translations: {
+        type: 'string',
+        enum: ['preview'],
+        description: 'Set to `preview` to attach the entry’s sibling translations. An error on a type that is not localized.'
+    },
+    relationLimit: {
+        type: 'integer',
+        minimum: 1,
+        maximum: entries_constants_1.MAX_PAGE_SIZE,
+        description: `Links per expanded relation field (1…${entries_constants_1.MAX_PAGE_SIZE}). The field's \`total\` always reports the true count.`
+    },
+    mediaLimit: {
+        type: 'integer',
+        minimum: 1,
+        maximum: entries_constants_1.MAX_PAGE_SIZE,
+        description: `Assets per expanded media field (1…${entries_constants_1.MAX_PAGE_SIZE}).`
+    }
+};
+/** An object schema with no extra keys allowed. */
+function object(properties, required = []) {
+    return {
+        type: 'object',
+        properties,
+        ...(required.length ? { required } : {}),
+        additionalProperties: false
+    };
+}
+/** `content_types_list` — no arguments. */
+exports.LIST_TYPES_SCHEMA = object({});
+/** `content_type_get` */
+exports.GET_TYPE_SCHEMA = object({ typeName: TYPE_NAME }, [
+    'typeName'
+]);
+/** `content_list` */
+exports.LIST_ENTRIES_SCHEMA = object({
+    typeName: TYPE_NAME,
+    search: {
+        type: 'string',
+        maxLength: 255,
+        description: 'Free-text, case-insensitive search across the type’s text-like columns.'
+    },
+    filter: {
+        type: 'string',
+        maxLength: entries_constants_1.FILTER_MAX_LENGTH,
+        description: 'Structured filter tree as a JSON **string**, e.g. `{"and":[{"field":"featured","op":"eq","value":true}]}`. Filterable: the type’s scalar fields plus `id`, `createdAt`, `updatedAt`, `publishedAt`, and on localized types `locale` and `localeGroupId`.'
+    },
+    sort: {
+        type: 'string',
+        description: 'A field name for ascending, `-`-prefixed for descending, e.g. `-publishedAt`. Defaults to newest-updated first.'
+    },
+    page: {
+        type: 'integer',
+        minimum: 1,
+        description: '1-based page number.'
+    },
+    pageSize: {
+        type: 'integer',
+        minimum: 1,
+        maximum: entries_constants_1.MAX_PAGE_SIZE,
+        description: `Rows per page (1…${entries_constants_1.MAX_PAGE_SIZE}, default ${entries_constants_1.DEFAULT_PAGE_SIZE}). Keep it small — every row costs context.`
+    },
+    fields: FIELDS,
+    locale: LOCALE,
+    status: STATUS
+}, ['typeName']);
+/** `content_get` */
+exports.GET_ENTRY_SCHEMA = object({
+    typeName: TYPE_NAME,
+    ...LOCATOR,
+    fields: FIELDS,
+    locale: LOCALE,
+    status: STATUS,
+    ...EXPANSIONS
+}, ['typeName']);
+/** `content_relations` */
+exports.RELATIONS_SCHEMA = object({
+    typeName: TYPE_NAME,
+    ...LOCATOR,
+    field: {
+        type: 'string',
+        description: 'The relation field to page, e.g. `tags`.'
+    },
+    page: { type: 'integer', minimum: 1, description: '1-based page.' },
+    pageSize: {
+        type: 'integer',
+        minimum: 1,
+        maximum: entries_constants_1.MAX_PAGE_SIZE,
+        description: `Links per page (1…${entries_constants_1.MAX_PAGE_SIZE}).`
+    },
+    locale: LOCALE,
+    status: STATUS
+}, ['typeName', 'field']);
+/** `content_media` */
+exports.MEDIA_SCHEMA = object({
+    typeName: TYPE_NAME,
+    ...LOCATOR,
+    locale: LOCALE,
+    status: STATUS,
+    mediaLimit: EXPANSIONS['mediaLimit']
+}, ['typeName']);
+/** `content_translations` */
+exports.TRANSLATIONS_SCHEMA = object({
+    typeName: TYPE_NAME,
+    ...LOCATOR,
+    fields: FIELDS,
+    locale: LOCALE,
+    status: STATUS
+}, ['typeName']);
+/** The `values` bag — open, because its real shape is per content type. */
+const VALUES = {
+    type: 'object',
+    additionalProperties: true,
+    description: 'Field values keyed by field name. The accepted shape is the content type’s own — call `content_type_get` first to see it. A media field takes asset ids; an owning single relation takes the target’s entry id.'
+};
+/** Relation deltas — assign/unassign, shared by create and update. */
+const RELATION_DELTAS = {
+    type: 'object',
+    additionalProperties: true,
+    description: 'Relation changes keyed by relation field: `{"tags":{"link":["<id>"],"unlink":["<id>"]}}`. A delta, not a replacement — ids you do not mention are left alone. Many-to-many and inverse relations only; set an owning single relation through `values`. Add `"by":"localeGroup"` to pass translation-group ids instead of entry ids.'
+};
+/** `content_create` */
+exports.CREATE_SCHEMA = object({
+    typeName: TYPE_NAME,
+    values: VALUES,
+    relations: RELATION_DELTAS,
+    locale: {
+        ...LOCALE,
+        description: 'Locale the new row is written in. Absent means the default locale.'
+    },
+    localeGroupId: {
+        type: 'string',
+        format: 'uuid',
+        description: 'Join an existing translation group — this is how you add a language to a record that already exists. Take `localeGroupId` off any read and pass it with a different `locale`.'
+    }
+}, ['typeName', 'values']);
+/** `content_update` */
+exports.UPDATE_SCHEMA = object({
+    typeName: TYPE_NAME,
+    ...LOCATOR,
+    values: {
+        ...VALUES,
+        description: 'Fields to change. A **partial** update: omitted fields are left alone, and an explicit `null` clears one. You do not need to send the whole record.'
+    },
+    relations: RELATION_DELTAS,
+    locale: LOCALE
+}, ['typeName', 'values']);
+/** `content_publish` / `content_unpublish` / `content_delete` */
+exports.ENTRY_ACTION_SCHEMA = object({
+    typeName: TYPE_NAME,
+    ...LOCATOR,
+    locale: LOCALE
+}, ['typeName']);
+/**
+ * `content_bulk_save` — the batch form of create + update.
+ *
+ * One `items` array rather than a `creates` and an `updates` list: a model
+ * working from a list of records knows which ones it read an id for and which
+ * it did not, and asking it to partition them first is a step it can get wrong
+ * for no benefit. The addressing inside an item is the same addressing the
+ * single-entry tools take as top-level arguments.
+ */
+exports.BULK_SAVE_SCHEMA = object({
+    typeName: TYPE_NAME,
+    items: {
+        type: 'array',
+        minItems: 1,
+        maxItems: entries_constants_1.BULK_MAX_SAVE_ITEMS,
+        description: `The entries to save (1…${entries_constants_1.BULK_MAX_SAVE_ITEMS}), applied in order. Every item is reported back at the same position, so a partial batch is legible.`,
+        items: object({
+            id: {
+                type: 'string',
+                format: 'uuid',
+                description: 'The entry to update. Omit to create a new one.'
+            },
+            op: {
+                type: 'string',
+                enum: ['create', 'update'],
+                description: 'What this item does. Inferred from the addressing — an `id` means update, no `id` and no `localeGroupId` means create — and required only when you pass `localeGroupId` alone, which could mean either adding that record’s row in `locale` or changing the row it already has there.'
+            },
+            values: VALUES,
+            relations: RELATION_DELTAS,
+            locale: LOCALE,
+            localeGroupId: {
+                type: 'string',
+                format: 'uuid',
+                description: 'The translation group this row belongs to — joined on a create, addressed together with `locale` on an update.'
+            }
+        })
+    }
+}, ['typeName', 'items']);
+/** `content_bulk_publish` / `content_bulk_unpublish` / `content_bulk_delete`. */
+exports.BULK_IDS_SCHEMA = object({
+    typeName: TYPE_NAME,
+    ids: {
+        type: 'array',
+        minItems: 1,
+        maxItems: entries_constants_1.BULK_MAX_IDS,
+        items: { type: 'string', format: 'uuid' },
+        description: `Entry ids to act on (1…${entries_constants_1.BULK_MAX_IDS}). Ids from another workspace, or that never existed, simply do not match — they are not an error.`
+    }
+}, ['typeName', 'ids']);

package/dist/lib/public/controllers/get-public-entry.controller.d.ts

@@ -0,0 +1,26 @@
+import type { ContentTypeRegistry } from '../../registry/content-type-registry';
+import { EntryWriterService } from '../../entries/infrastructure/persistence/entry-writer.service';
+import type { EntryRecord, EntryRelationsView, RelationFieldView } from '../../entries/types/entry-list-view';
+/**
+ * `GET /api/v1/content/:typeName/:id[/relations[/:field]]` — the external,
+ * bearer-token-authenticated single-entry reads, mirroring the admin's
+ * `GetEntryController`. Every route is scoped to the token's workspace
+ * (`@CurrentWorkspace()`), so an id outside it reads as 404. Read-only:
+ * `content:read`, enforced against the token's scope by {@link ApiTokenGuard}.
+ */
+export declare class GetPublicEntryController {
+    private readonly registry;
+    private readonly writer;
+    constructor(registry: ContentTypeRegistry, writer: EntryWriterService);
+    /**
+     * One live entry by id (404 if unknown or soft-deleted in the workspace).
+     * `?fields=title,slug` narrows the returned `values` bag to those fields;
+     * omitted, the whole record is returned. An unknown name is a 400.
+     */
+    getOne(typeName: string, id: string, workspaceId: string, fields?: string): Promise<EntryRecord>;
+    /** First page of every relation field's links for one entry. */
+    getRelations(typeName: string, id: string, workspaceId: string): Promise<EntryRelationsView>;
+    /** One page of a single relation field's links (`{ items, total }`). */
+    getRelationField(typeName: string, id: string, field: string, workspaceId: string, page?: string, pageSize?: string): Promise<RelationFieldView>;
+}
+//# sourceMappingURL=get-public-entry.controller.d.ts.map

package/dist/lib/public/controllers/get-public-entry.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-public-entry.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/public/controllers/get-public-entry.controller.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,+DAA+D,CAAC;AAInG,OAAO,KAAK,EACR,WAAW,EACX,kBAAkB,EAClB,iBAAiB,EACpB,MAAM,qCAAqC,CAAC;AAE7C;;;;;;GAMG;AACH,qBAIa,wBAAwB;IAG7B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAG/C;;;;OAIG;IAEH,MAAM,CACiB,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACtB,MAAM,CAAC,EAAE,MAAM,GACjC,OAAO,CAAC,WAAW,CAAC;IAKvB,gEAAgE;IAE1D,YAAY,CACK,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,kBAAkB,CAAC;IAO9B,wEAAwE;IAExE,gBAAgB,CACO,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,EACT,WAAW,EAAE,MAAM,EACxB,IAAI,CAAC,EAAE,MAAM,EACT,QAAQ,CAAC,EAAE,MAAM,GACrC,OAAO,CAAC,iBAAiB,CAAC;CAWhC"}

package/dist/lib/public/controllers/list-public-entries.controller.d.ts

@@ -0,0 +1,24 @@
+import type { ContentTypeRegistry } from '../../registry/content-type-registry';
+import { EntriesService } from '../../entries/infrastructure/queries/entries.service';
+import { ListEntriesQueryDto } from '../../entries/http/dto/list-entries-query.dto';
+import type { EntryListView } from '../../entries/types/entry-list-view';
+/**
+ * `GET /api/v1/content/:typeName` — the external, **bearer-token**-authenticated
+ * mirror of the admin's records list. Same generic pipeline
+ * (`search`/`filter`/`sort`/pagination + relation filtering), same
+ * `{ items, total, page, pageSize }` envelope — the only difference is the
+ * caller: an API token instead of a session.
+ *
+ * `@Public()` opts the route out of the app-wide session `AuthGuard` so
+ * {@link ApiTokenGuard} owns authentication; the guard authorizes the token's
+ * scope against `content:read` and mirrors the token's workspace onto the
+ * request, so `@CurrentWorkspace()` scopes the query exactly as the admin
+ * routes do — a token can never read another workspace's entries.
+ */
+export declare class ListPublicEntriesController {
+    private readonly registry;
+    private readonly entries;
+    constructor(registry: ContentTypeRegistry, entries: EntriesService);
+    list(typeName: string, query: ListEntriesQueryDto, workspaceId: string): Promise<EntryListView>;
+}
+//# sourceMappingURL=list-public-entries.controller.d.ts.map

package/dist/lib/public/controllers/list-public-entries.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-public-entries.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/public/controllers/list-public-entries.controller.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,sDAAsD,CAAC;AACtF,OAAO,EAAE,mBAAmB,EAAE,MAAM,+CAA+C,CAAC;AAEpF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEzE;;;;;;;;;;;;GAYG;AACH,qBAIa,2BAA2B;IAGhC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,EAAE,cAAc;IAI5C,IAAI,CACmB,QAAQ,EAAE,MAAM,EAC1B,KAAK,EAAE,mBAAmB,EACf,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,aAAa,CAAC;CAI5B"}

package/dist/lib/public/controllers/public-schema.controller.d.ts

@@ -0,0 +1,18 @@
+import type { ContentTypeRegistry, SerializedContentType, SerializedContentTypeSummary } from '../../registry/content-type-registry';
+/**
+ * `GET /api/v1/content-schema[/:name]` — schema discovery for the external API,
+ * so a developer can enumerate the available content types (collections +
+ * pages) and read one type's full field list before querying it. Same registry
+ * projection the admin schema routes serve, behind the bearer-token guard on
+ * `content:read`. Schema is not workspace-specific — the types are code-defined
+ * — but access still requires a valid token.
+ */
+export declare class PublicSchemaController {
+    private readonly registry;
+    constructor(registry: ContentTypeRegistry);
+    /** Summaries of every content type. */
+    list(): SerializedContentTypeSummary[];
+    /** One type's full field schema (404 if unknown). */
+    get(name: string): SerializedContentType;
+}
+//# sourceMappingURL=public-schema.controller.d.ts.map

package/dist/lib/public/controllers/public-schema.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-schema.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/public/controllers/public-schema.controller.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACR,mBAAmB,EACnB,qBAAqB,EACrB,4BAA4B,EAC/B,MAAM,sCAAsC,CAAC;AAE9C;;;;;;;GAOG;AACH,qBAIa,sBAAsB;IAG3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,mBAAmB;IAGlD,uCAAuC;IAEvC,IAAI,IAAI,4BAA4B,EAAE;IAItC,qDAAqD;IAErD,GAAG,CAAgB,IAAI,EAAE,MAAM,GAAG,qBAAqB;CAO1D"}

package/dist/lib/public-api/http/api-token-request.d.ts

@@ -0,0 +1,41 @@
+import type { ApiTokenScope, AuthenticatedRequest } from '@orthacms/identity-server';
+/**
+ * The token a public-API request authenticated with, as {@link ApiTokenGuard}
+ * attaches it. A deliberately narrow projection of the stored record: the
+ * hash, the creator, and the timestamps are management concerns and have no
+ * business on the request.
+ */
+export interface PublicApiToken {
+    /** Stable token id — what a log line or a rate limiter keys on. */
+    id: string;
+    /** The token's display name, for diagnostics. */
+    name: string;
+    /** Access level, which the guard turns into a permission set. */
+    scope: ApiTokenScope;
+    /** Every workspace this token may act in — always at least one. */
+    workspaceIds: readonly string[];
+    /**
+     * The user who minted the token, when still known.
+     *
+     * Carried for **attribution on writes**, not for authorization — the token
+     * acts as itself, and this user's role grants are never consulted (revoking
+     * the token has to be enough). A media upload has a NOT NULL `uploaded_by`,
+     * so something must go there; the accountable human is the one who created
+     * the credential, and recording them keeps the Media Library's uploader
+     * column meaningful instead of blank.
+     */
+    createdBy: string | null;
+}
+/**
+ * A public-API request after {@link ApiTokenGuard} has run: the verified token
+ * is attached as `apiToken`, and {@link ApiTokenWorkspaceGuard} additionally
+ * stamps the resolved `workspaceId` (inherited from `AuthenticatedRequest`, so
+ * `@CurrentWorkspace()` reads it exactly as it does on the admin routes).
+ *
+ * `user` is always `undefined` here — these routes are `@Public()`, so the
+ * app-wide session `AuthGuard` never runs on them.
+ */
+export interface ApiTokenRequest extends AuthenticatedRequest {
+    apiToken?: PublicApiToken;
+}
+//# sourceMappingURL=api-token-request.d.ts.map

package/dist/lib/public-api/http/api-token-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-token-request.d.ts","sourceRoot":"","sources":["../../../../src/lib/public-api/http/api-token-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,aAAa,EACb,oBAAoB,EACvB,MAAM,2BAA2B,CAAC;AAEnC;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC3B,mEAAmE;IACnE,EAAE,EAAE,MAAM,CAAC;IACX,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,KAAK,EAAE,aAAa,CAAC;IACrB,mEAAmE;IACnE,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC;;;;;;;;;OASG;IACH,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAgB,SAAQ,oBAAoB;IACzD,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC7B"}

package/dist/lib/public-api/http/api-token-request.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/public-api/http/controllers/public-content-types.controller.d.ts

@@ -0,0 +1,31 @@
+import type { ContentTypeRegistry, SerializedContentType, SerializedContentTypeSummary } from '../../../registry/content-type-registry';
+import { WorkspaceGrantsQuery } from '../../../content-types/queries/workspace-grants.query';
+/** The discovery list: every type this token's workspace can be read for. */
+export interface PublicContentTypeListView {
+    items: SerializedContentTypeSummary[];
+}
+/**
+ * `GET /api/v1/content-types` — the **schema-discovery** half of the public
+ * API. A consumer asks what it can read and how each type is shaped, instead of
+ * hard-coding a model it can't see.
+ *
+ * Both routes are **pruned to the workspace's content grants**, and so is
+ * `/v1/content/:typeName` — so the discovery list is exactly the set of names
+ * that will not 404, and a token can't enumerate types its workspace doesn't
+ * expose.
+ *
+ * The field schema is served whole, including relation fields. Those describe
+ * the real model even though the entry read is flat: an owning single relation
+ * appears in `values` as the target's raw id (follow it with a second read),
+ * while a many-relation and an inverse carry no value in a public entry at all.
+ */
+export declare class PublicContentTypesController {
+    private readonly registry;
+    private readonly grants;
+    constructor(registry: ContentTypeRegistry, grants: WorkspaceGrantsQuery);
+    /** `GET /api/v1/content-types` — summaries of every readable type. */
+    list(workspaceId: string): Promise<PublicContentTypeListView>;
+    /** `GET /api/v1/content-types/:name` — one type's full field schema. */
+    get(name: string, workspaceId: string): Promise<SerializedContentType>;
+}
+//# sourceMappingURL=public-content-types.controller.d.ts.map

package/dist/lib/public-api/http/controllers/public-content-types.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-content-types.controller.d.ts","sourceRoot":"","sources":["../../../../../src/lib/public-api/http/controllers/public-content-types.controller.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACR,mBAAmB,EACnB,qBAAqB,EACrB,4BAA4B,EAC/B,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uDAAuD,CAAC;AAK7F,6EAA6E;AAC7E,MAAM,WAAW,yBAAyB;IACtC,KAAK,EAAE,4BAA4B,EAAE,CAAC;CACzC;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAWa,4BAA4B;IAGjC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,oBAAoB;IAGjD,sEAAsE;IAOhE,IAAI,CACc,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,yBAAyB,CAAC;IASrC,wEAAwE;IAOlE,GAAG,CACU,IAAI,EAAE,MAAM,EACP,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,qBAAqB,CAAC;CAcpC"}

package/dist/lib/public-api/http/controllers/public-content-types.controller.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicContentTypesController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const identity_server_1 = require("@orthacms/identity-server");
+const workspaces_server_1 = require("@orthacms/workspaces-server");
+const content_tokens_1 = require("../../../content.tokens");
+const workspace_grants_query_1 = require("../../../content-types/queries/workspace-grants.query");
+const api_token_guard_1 = require("../guards/api-token.guard");
+const api_token_workspace_guard_1 = require("../guards/api-token-workspace.guard");
+const resolve_granted_type_1 = require("./resolve-granted-type");
+/**
+ * `GET /api/v1/content-types` — the **schema-discovery** half of the public
+ * API. A consumer asks what it can read and how each type is shaped, instead of
+ * hard-coding a model it can't see.
+ *
+ * Both routes are **pruned to the workspace's content grants**, and so is
+ * `/v1/content/:typeName` — so the discovery list is exactly the set of names
+ * that will not 404, and a token can't enumerate types its workspace doesn't
+ * expose.
+ *
+ * The field schema is served whole, including relation fields. Those describe
+ * the real model even though the entry read is flat: an owning single relation
+ * appears in `values` as the target's raw id (follow it with a second read),
+ * while a many-relation and an inverse carry no value in a public entry at all.
+ */
+let PublicContentTypesController = class PublicContentTypesController {
+    registry;
+    grants;
+    constructor(registry, grants) {
+        this.registry = registry;
+        this.grants = grants;
+    }
+    /** `GET /api/v1/content-types` — summaries of every readable type. */
+    async list(workspaceId) {
+        const granted = await this.grants.grantedSlugs(workspaceId);
+        return {
+            items: this.registry
+                .summaries()
+                .filter((summary) => granted.has(summary.name))
+        };
+    }
+    /** `GET /api/v1/content-types/:name` — one type's full field schema. */
+    async get(name, workspaceId) {
+        // Resolve through the same grant gate as the entry routes, so an
+        // ungranted type reads identically here and there (one 404, no
+        // enumeration signal). The registry then serializes the resolved type.
+        const { type } = await (0, resolve_granted_type_1.resolveGrantedType)(this.registry, this.grants, name, workspaceId);
+        // Registered by definition (resolveGrantedType returned it), so the
+        // serialize can't miss — the non-null assertion documents that.
+        return this.registry.serialize(type.name);
+    }
+};
+exports.PublicContentTypesController = PublicContentTypesController;
+tslib_1.__decorate([
+    (0, common_1.Get)(),
+    (0, swagger_1.ApiOperation)({
+        summary: 'List the content types this token can read',
+        description: 'Summaries (name, kind, label, and the publishable/paranoid/i18n flags) of every content type granted to the requested workspace.'
+    }),
+    tslib_1.__param(0, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], PublicContentTypesController.prototype, "list", null);
+tslib_1.__decorate([
+    (0, common_1.Get)(':name'),
+    (0, swagger_1.ApiOperation)({
+        summary: 'Read one content type’s field schema',
+        description: 'Every field of the type with its kind, validation rules, and options — what a client renders or types its models from. 404 when the type is unknown or not granted to the workspace.'
+    }),
+    tslib_1.__param(0, (0, common_1.Param)('name')),
+    tslib_1.__param(1, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], PublicContentTypesController.prototype, "get", null);
+exports.PublicContentTypesController = PublicContentTypesController = tslib_1.__decorate([
+    (0, identity_server_1.Public)(),
+    (0, common_1.UseGuards)(api_token_guard_1.ApiTokenGuard, api_token_workspace_guard_1.ApiTokenWorkspaceGuard),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.CONTENT_READ),
+    (0, swagger_1.ApiSecurity)('apiToken'),
+    (0, swagger_1.ApiHeader)({
+        name: 'X-Workspace-Id',
+        required: false,
+        description: "The workspace whose grants scope the result. Required when the token covers more than one workspace; optional when it covers exactly one. A workspace outside the token's bucket is a 403."
+    }),
+    (0, common_1.Controller)('v1/content-types'),
+    tslib_1.__param(0, (0, content_tokens_1.InjectContentRegistry)()),
+    tslib_1.__metadata("design:paramtypes", [Function, workspace_grants_query_1.WorkspaceGrantsQuery])
+], PublicContentTypesController);

package/dist/lib/public-api/http/controllers/public-entries.controller.d.ts

@@ -0,0 +1,101 @@
+import type { ContentTypeRegistry } from '../../../registry/content-type-registry';
+import { WorkspaceGrantsQuery } from '../../../content-types/queries/workspace-grants.query';
+import { PublicEntriesQuery } from '../../infrastructure/public-entries.query';
+import type { PublicEntry, PublicEntryListView } from '../../types/public-entry';
+import type { PublicMediaFieldView, PublicRelationFieldView } from '../../types/public-expansion';
+import { PublicEntryQueryDto, PublicListEntriesQueryDto } from '../dto/public-list-entries-query.dto';
+/** One entry's media assets, keyed by field name. */
+export interface PublicEntryMediaView {
+    media: Record<string, PublicMediaFieldView>;
+}
+/** One entry's sibling translations. */
+export interface PublicEntryTranslationsView {
+    translations: PublicEntry[];
+}
+/**
+ * `GET /api/v1/content/...` — the **public, token-authenticated read API** an
+ * external site or app fetches content with. One route pair serves every
+ * code-defined type: `:typeName` is resolved against the registry (and the
+ * workspace's grants) at request time.
+ *
+ * `@Public()` opts these routes out of the session `AuthGuard`; `ApiTokenGuard`
+ * then authenticates the `Authorization: Bearer` token and checks
+ * `content:read` against its scope, and `ApiTokenWorkspaceGuard` resolves which
+ * of the token's workspaces the request targets (the `X-Workspace-Id` header,
+ * or the only one when the token covers a single workspace).
+ *
+ * Reads are flat and live-only — published entries, no drafts, no soft-deleted
+ * rows, and `values` carries the entry's own data only (no relation or media
+ * fields, in either direction). See {@link PublicEntriesQuery} for the exact
+ * visibility rule and `types/public-entry.ts` for the wire shape.
+ *
+ * A `single` (page) type is served by the same list route as a collection: with
+ * localization a single still has one row per locale, so a list envelope is the
+ * honest shape for both — take `items[0]`.
+ */
+export declare class PublicEntriesController {
+    private readonly registry;
+    private readonly grants;
+    private readonly entries;
+    constructor(registry: ContentTypeRegistry, grants: WorkspaceGrantsQuery, entries: PublicEntriesQuery);
+    /** `GET /api/v1/content/:typeName` — one page of published entries. */
+    list(typeName: string, query: PublicListEntriesQueryDto, workspaceId: string): Promise<PublicEntryListView>;
+    /**
+     * `GET /api/v1/content/:typeName/group/:localeGroupId` — one published
+     * entry addressed by its translation group and the requested locale.
+     */
+    getByLocaleGroup(typeName: string, localeGroupId: string, query: PublicEntryQueryDto, workspaceId: string): Promise<PublicEntry>;
+    /**
+     * `GET /api/v1/content/:typeName/group/:localeGroupId/relations/:field` —
+     * one page of a relation field's links, for the group's row in the
+     * requested locale.
+     */
+    getRelationFieldByLocaleGroup(typeName: string, localeGroupId: string, field: string, query: PublicListEntriesQueryDto, workspaceId: string): Promise<PublicRelationFieldView>;
+    /**
+     * `GET /api/v1/content/:typeName/group/:localeGroupId/media` — the media
+     * assets of the group's row in the requested locale.
+     */
+    getMediaByLocaleGroup(typeName: string, localeGroupId: string, query: PublicEntryQueryDto, workspaceId: string): Promise<PublicEntryMediaView>;
+    /**
+     * `GET /api/v1/content/:typeName/group/:localeGroupId/translations` — the
+     * group's other published locale rows.
+     *
+     * Reachable without holding any entry id at all: the group id alone names
+     * every language a story is live in.
+     */
+    getTranslationsByLocaleGroup(typeName: string, localeGroupId: string, query: PublicEntryQueryDto, workspaceId: string): Promise<PublicEntryTranslationsView>;
+    /** `GET /api/v1/content/:typeName/:id` — one published entry. */
+    getOne(typeName: string, id: string, query: PublicEntryQueryDto, workspaceId: string): Promise<PublicEntry>;
+    /**
+     * `GET /api/v1/content/:typeName/:id/relations/:field` — one page of a
+     * single relation field's links.
+     *
+     * The **only** relation route, deliberately. An all-fields sibling
+     * (`/:id/relations`) used to sit here and returned exactly what
+     * `GET /:id?relations=preview` already returns minus the entry — a second
+     * spelling of one read, on a contract that has to stay still. Paging one
+     * field past the preview's cap is the one thing a query parameter cannot
+     * express, so it is the one thing that keeps a route.
+     */
+    getRelationField(typeName: string, id: string, field: string, query: PublicListEntriesQueryDto, workspaceId: string): Promise<PublicRelationFieldView>;
+    /**
+     * `GET /api/v1/content/:typeName/:id/media` — every media field of one
+     * entry, resolved to asset metadata and URLs.
+     */
+    getMedia(typeName: string, id: string, query: PublicEntryQueryDto, workspaceId: string): Promise<PublicEntryMediaView>;
+    /**
+     * `GET /api/v1/content/:typeName/:id/translations` — the entry's other
+     * locale rows. The sibling of `?translations=preview`, for a consumer that
+     * already holds the entry.
+     */
+    getTranslations(typeName: string, id: string, query: PublicEntryQueryDto, workspaceId: string): Promise<PublicEntryTranslationsView>;
+    /** @see getOne */
+    private readEntry;
+    /** @see getRelationField */
+    private readRelationField;
+    /** @see getMedia */
+    private readMedia;
+    /** @see getTranslations */
+    private readTranslations;
+}
+//# sourceMappingURL=public-entries.controller.d.ts.map

package/dist/lib/public-api/http/controllers/public-entries.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-entries.controller.d.ts","sourceRoot":"","sources":["../../../../../src/lib/public-api/http/controllers/public-entries.controller.ts"],"names":[],"mappings":"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"}