@vitnode/core 1.2.0-canary.78 → 2.0.0-canary.2

package/dist/src/content/server/localized-service.d.ts

@@ -0,0 +1,30 @@
+import type { Context } from "hono";
+import type { ContentActor } from "../revisions";
+import type { AnyContentTypeDefinition, ContentLocalizedValues, ContentSelect, ContentSharedValues, ContentTranslationRow } from "../types";
+import type { ContentDatabase, ContentService } from "./service";
+import type { ContentTranslationEditorialService } from "./translation-editorial-service";
+import type { ContentTranslationModel } from "./translation-model";
+export interface ContentLocalizedCreateInput<TDefinition> {
+    shared: ContentSharedValues<TDefinition>;
+    translation: ContentLocalizedValues<TDefinition>;
+}
+export interface ContentLocalizedCreateOptions {
+    actor?: ContentActor;
+    locale?: string;
+    tx?: ContentDatabase;
+}
+export interface ContentLocalizedCreateResult<TDefinition> {
+    row: ContentSelect<TDefinition>;
+    translation: ContentTranslationRow<TDefinition>;
+}
+export interface ContentLocalizedService<TDefinition> {
+    create: (input: ContentLocalizedCreateInput<TDefinition>, options?: ContentLocalizedCreateOptions) => Promise<ContentLocalizedCreateResult<TDefinition>>;
+}
+export declare const createContentLocalizedService: <TDefinition extends AnyContentTypeDefinition>({ c, definition, editorial, service, translations, }: {
+    c: Context;
+    definition: TDefinition;
+    editorial?: ContentTranslationEditorialService<TDefinition>;
+    service: ContentService<TDefinition>;
+    translations: ContentTranslationModel<TDefinition>;
+}) => ContentLocalizedService<TDefinition>;
+//# sourceMappingURL=localized-service.d.ts.map

package/dist/src/content/server/localized-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localized-service.d.ts","sourceRoot":"","sources":["../../../../src/content/server/localized-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EACV,wBAAwB,EACxB,sBAAsB,EACtB,aAAa,EACb,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,iCAAiC,CAAC;AAC1F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAKnE,MAAM,WAAW,2BAA2B,CAAC,WAAW;IAEtD,MAAM,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAEzC,WAAW,EAAE,sBAAsB,CAAC,WAAW,CAAC,CAAC;CAClD;AAED,MAAM,WAAW,6BAA6B;IAU5C,KAAK,CAAC,EAAE,YAAY,CAAC;IAKrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,EAAE,CAAC,EAAE,eAAe,CAAC;CACtB;AAED,MAAM,WAAW,4BAA4B,CAAC,WAAW;IACvD,GAAG,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAChC,WAAW,EAAE,qBAAqB,CAAC,WAAW,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,uBAAuB,CAAC,WAAW;IAUlD,MAAM,EAAE,CACN,KAAK,EAAE,2BAA2B,CAAC,WAAW,CAAC,EAC/C,OAAO,CAAC,EAAE,6BAA6B,KACpC,OAAO,CAAC,4BAA4B,CAAC,WAAW,CAAC,CAAC,CAAC;CACzD;AASD,eAAO,MAAM,6BAA6B,GACxC,WAAW,SAAS,wBAAwB,EAC5C,sDAMC;IACD,CAAC,EAAE,OAAO,CAAC;IACX,UAAU,EAAE,WAAW,CAAC;IAQxB,SAAS,CAAC,EAAE,kCAAkC,CAAC,WAAW,CAAC,CAAC;IAC5D,OAAO,EAAE,cAAc,CAAC,WAAW,CAAC,CAAC;IACrC,YAAY,EAAE,uBAAuB,CAAC,WAAW,CAAC,CAAC;CACpD,KAAG,uBAAuB,CAAC,WAAW,CAoEtC,CAAC"}

package/dist/src/content/server/localized-service.js

@@ -0,0 +1 @@
+import{contentTypeName}from"../admin/labels.js";import{ContentEngineError}from"../errors.js";export const createContentLocalizedService=({c,definition,editorial,service,translations})=>{const contentTypeId=definition.id;if(!definition.localization.enabled){throw new ContentEngineError("The localized service needs `localization: { enabled: true, defaultLocale }` on the content type.",{contentTypeId})}const{defaultLocale}=definition.localization;return{create:async({shared,translation},options={})=>{const locale=options.locale??defaultLocale;if(locale.toLowerCase()!==defaultLocale.toLowerCase()){throw new ContentEngineError(`A ${contentTypeName(definition.id)} is created in its default locale "${defaultLocale}", not "${locale}". Create it first, then add the "${locale}" translation.`,{contentTypeId})}const run=async tx=>{const language=await translations.resolveDefaultLanguage({tx});const row=await service.create(shared,{tx});if(editorial&&options.actor){const outcome=await editorial.create(row.id,language.locale,translation,{actor:options.actor,tx});return{row,translation:outcome.row}}const created=await translations.create(row.id,language.locale,translation,{tx});return{row,translation:created}};if(options.tx)return await run(options.tx);return await c.get("db").transaction(async tx=>await run(tx))}}};

package/dist/src/content/server/model.d.ts

@@ -0,0 +1,51 @@
+import type { PgColumn } from "drizzle-orm/pg-core";
+import type { Context } from "hono";
+import type { ContentSchemas, ContentTranslationSchemas } from "../schemas";
+import type { AnyContentTypeDefinition, ResolvedContentLocalizationConfig } from "../types";
+import type { ContentAdvancedStore } from "./advanced-store";
+import type { ContentDeliveryService } from "./delivery-service";
+import type { ContentEditorialService } from "./editorial-service";
+import type { ContentLocalizedService } from "./localized-service";
+import type { ContentPublicService } from "./public-service";
+import type { ContentService } from "./service";
+import type { ContentTranslationEditorialService } from "./translation-editorial-service";
+import type { ContentTranslationModel } from "./translation-model";
+import type { ContentAdvancedTables, ContentColumnName, ContentReferences, ContentTableFor, ContentTranslationColumnName, ContentTranslationTableFor } from "./types";
+export interface ContentModel<TDefinition extends AnyContentTypeDefinition> {
+    advanced: ContentAdvancedStore;
+    advancedTables: ContentAdvancedTables;
+    columns: Record<ContentColumnName<TDefinition>, PgColumn>;
+    definition: TDefinition;
+    deliveryService: ((c: Context, options: {
+        pluginId: string;
+    }) => ContentDeliveryService) | undefined;
+    editorialService: ((c: Context, options: {
+        pluginId: string;
+    }) => ContentEditorialService<TDefinition>) | undefined;
+    localization: ResolvedContentLocalizationConfig;
+    localizedService: ((c: Context, options?: {
+        pluginId?: string;
+    }) => ContentLocalizedService<TDefinition>) | undefined;
+    publicService: ((c: Context) => ContentPublicService<TDefinition>) | undefined;
+    schemas: ContentSchemas<TDefinition>;
+    service: (c: Context) => ContentService<TDefinition>;
+    table: ContentTableFor<TDefinition>;
+    translationColumns: null | Record<ContentTranslationColumnName<TDefinition>, PgColumn>;
+    translationEditorialService: ((c: Context, options: {
+        pluginId: string;
+    }) => ContentTranslationEditorialService<TDefinition>) | undefined;
+    translationSchemas: ContentTranslationSchemas<TDefinition> | null;
+    translationService: ((c: Context) => ContentTranslationModel<TDefinition>) | undefined;
+    translationTable: ContentTranslationTableFor<TDefinition> | null;
+}
+export type AnyContentModel = ContentModel<any>;
+export declare const contentDefinitionOf: (model: AnyContentModel) => AnyContentTypeDefinition;
+export interface RegisteredContentModel {
+    model: AnyContentModel;
+    pluginId: string;
+}
+export declare const findContentModel: (models: readonly RegisteredContentModel[], contentTypeId: string) => RegisteredContentModel | undefined;
+export declare const createContentModel: <TDefinition extends AnyContentTypeDefinition>(definition: TDefinition, options?: {
+    references?: ContentReferences<TDefinition["fields"]>;
+}) => ContentModel<TDefinition>;
+//# sourceMappingURL=model.d.ts.map

package/dist/src/content/server/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../../src/content/server/model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,KAAK,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAC5E,OAAO,KAAK,EACV,wBAAwB,EACxB,iCAAiC,EAClC,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,iCAAiC,CAAC;AAC1F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EACV,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,4BAA4B,EAC5B,0BAA0B,EAC3B,MAAM,SAAS,CAAC;AAmBjB,MAAM,WAAW,YAAY,CAAC,WAAW,SAAS,wBAAwB;IAYxE,QAAQ,EAAE,oBAAoB,CAAC;IAc/B,cAAc,EAAE,qBAAqB,CAAC;IAEtC,OAAO,EAAE,MAAM,CAAC,iBAAiB,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,CAAC;IAC1D,UAAU,EAAE,WAAW,CAAC;IAaxB,eAAe,EACX,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,KAAK,sBAAsB,CAAC,GACvE,SAAS,CAAC;IASd,gBAAgB,EACZ,CAAC,CACC,CAAC,EAAE,OAAO,EACV,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,KAC1B,uBAAuB,CAAC,WAAW,CAAC,CAAC,GAC1C,SAAS,CAAC;IAQd,YAAY,EAAE,iCAAiC,CAAC;IAUhD,gBAAgB,EACZ,CAAC,CACC,CAAC,EAAE,OAAO,EACV,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,KAC5B,uBAAuB,CAAC,WAAW,CAAC,CAAC,GAC1C,SAAS,CAAC;IAQd,aAAa,EACX,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,oBAAoB,CAAC,WAAW,CAAC,CAAC,GAAG,SAAS,CAAC;IAElE,OAAO,EAAE,cAAc,CAAC,WAAW,CAAC,CAAC;IAErC,OAAO,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,cAAc,CAAC,WAAW,CAAC,CAAC;IAErD,KAAK,EAAE,eAAe,CAAC,WAAW,CAAC,CAAC;IAKpC,kBAAkB,EAAE,IAAI,GAAG,MAAM,CAC/B,4BAA4B,CAAC,WAAW,CAAC,EACzC,QAAQ,CACT,CAAC;IASF,2BAA2B,EACvB,CAAC,CACC,CAAC,EAAE,OAAO,EACV,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,KAC1B,kCAAkC,CAAC,WAAW,CAAC,CAAC,GACrD,SAAS,CAAC;IAEd,kBAAkB,EAAE,yBAAyB,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;IAMlE,kBAAkB,EAChB,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,uBAAuB,CAAC,WAAW,CAAC,CAAC,GAAG,SAAS,CAAC;IAUrE,gBAAgB,EAAE,0BAA0B,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;CAClE;AAUD,MAAM,MAAM,eAAe,GAAG,YAAY,CAoBxC,GAAG,CACJ,CAAC;AAgBF,eAAO,MAAM,mBAAmB,GAC9B,OAAO,eAAe,KACrB,wBAAwE,CAAC;AAS5E,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,eAAe,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAGD,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,SAAS,sBAAsB,EAAE,EACzC,eAAe,MAAM,KACpB,sBAAsB,GAAG,SACuC,CAAC;AAoBpE,eAAO,MAAM,kBAAkB,GAC7B,WAAW,SAAS,wBAAwB,EAE5C,YAAY,WAAW,EACvB,UAAS;IAAE,UAAU,CAAC,EAAE,iBAAiB,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAA;CAAO,KACtE,YAAY,CAAC,WAAW,CA6O1B,CAAC"}

package/dist/src/content/server/model.js

@@ -0,0 +1 @@
+import{ContentEngineError}from"../errors.js";import{createContentAdvancedStore}from"./advanced-store.js";import{createContentAdvancedTables}from"./advanced-tables.js";import{createContentDeliveryService}from"./delivery-service.js";import{createContentEditorialService}from"./editorial-service.js";import{createContentLocalizedPublicService}from"./localized-public-service.js";import{createContentLocalizedService}from"./localized-service.js";import{createContentPublicService}from"./public-service.js";import{createContentService}from"./service.js";import{contentTableColumns,createContentTable}from"./table.js";import{createContentTranslationEditorialService}from"./translation-editorial-service.js";import{createContentTranslationModel}from"./translation-model.js";import{contentTranslationTableColumns,createContentTranslationTable}from"./translation-table.js";export const contentDefinitionOf=model=>model.definition;export const findContentModel=(models,contentTypeId)=>models.find(entry=>entry.model.definition.id===contentTypeId);export const createContentModel=(definition,options={})=>{const table=createContentTable(definition,options);const columns=contentTableColumns(definition,table);const advancedTables=createContentAdvancedTables(definition,{...options,table});const advanced=createContentAdvancedStore({definition,table,tables:advancedTables});const schemas=definition.schemas;const localized=definition.localization.enabled;const translationTable=localized?createContentTranslationTable(definition,{table}):null;const translationColumns=translationTable?contentTranslationTableColumns(definition,translationTable):null;const translationSchemas=schemas.translation;const buildTranslations=c=>{if(!translationTable||!translationColumns||!translationSchemas){throw new ContentEngineError("This content type has no `localization` block, so it has no translations.",{contentTypeId:definition.id})}return createContentTranslationModel({c,columns:translationColumns,definition,schemas:translationSchemas,table,translationTable})};const model={advanced,advancedTables,columns,definition,deliveryService:definition.delivery.enabled&&definition.publicApi.enabled?(c,{pluginId})=>createContentDeliveryService({c,model,pluginId}):undefined,editorialService:definition.editorial.enabled?(c,{pluginId})=>createContentEditorialService({advanced,c,cascadeTranslations:localized&&translationSchemas?async({actor,itemId,operation,tx})=>{const translations=buildTranslations(c);const editorial=createContentTranslationEditorialService({c,definition,pluginId,schemas:translationSchemas,translations});const rows=await translations.findManyForItem(itemId,{tx});let moved=0;for(const row of rows){const language=await translations.resolveLanguage(row.locale,{requireEnabled:false,tx});if(operation==="publish"&&!language.isEnabled){continue}const outcome=await editorial[operation](itemId,row.locale,{actor,tx});if(outcome?.changed===true)moved+=1}return moved}:null,columns,definition,pluginId,schemas,table}):undefined,localization:definition.localization,localizedService:localized?(c,options)=>{const translations=buildTranslations(c);const owner=options?.pluginId;return createContentLocalizedService({c,definition,editorial:definition.editorial.enabled&&translationSchemas&&owner!==undefined?createContentTranslationEditorialService({c,definition,pluginId:owner,schemas:translationSchemas,translations}):undefined,service:createContentService({advanced,c,columns,definition,schemas,table}),translations})}:undefined,publicService:definition.publicApi.enabled?c=>localized&&translationTable&&translationColumns?createContentLocalizedPublicService({advanced,c,columns,definition,table,translationColumns,translationTable}):createContentPublicService({advanced,c,columns,definition,table}):undefined,schemas,service:c=>createContentService({advanced,c,columns,definition,schemas,table}),table,translationColumns,translationSchemas,translationEditorialService:localized&&definition.editorial.enabled&&translationSchemas?(c,{pluginId})=>createContentTranslationEditorialService({c,definition,pluginId,schemas:translationSchemas,translations:buildTranslations(c)}):undefined,translationService:localized?buildTranslations:undefined,translationTable};return model};

package/dist/src/content/server/module.d.ts

@@ -0,0 +1,7 @@
+import type { BuildModuleReturn } from "../../api/lib/module";
+import type { AnyContentModel } from "./model";
+export declare const buildContentAdminModule: <P extends string>({ contentTypes, pluginId, }: {
+    contentTypes: AnyContentModel[];
+    pluginId: P;
+}) => BuildModuleReturn<P, "content">;
+//# sourceMappingURL=module.d.ts.map

package/dist/src/content/server/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../src/content/server/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAgC/C,eAAO,MAAM,uBAAuB,GAAI,CAAC,SAAS,MAAM,EAAE,6BAGvD;IACD,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,QAAQ,EAAE,CAAC,CAAC;CACb,KAAG,iBAAiB,CAAC,CAAC,EAAE,SAAS,CAwCjC,CAAC"}

package/dist/src/content/server/module.js

@@ -0,0 +1 @@
+import{buildModule}from"../../api/lib/module.js";import{buildContentRoutes}from"./routes.js";import{createContentLocalizedSearchIndexer,createContentSearchIndexer}from"./search-indexer.js";import{assertContentReferences}from"./table.js";export const buildContentAdminModule=({contentTypes,pluginId})=>{const modules=contentTypes.map(model=>{assertContentReferences(model.table);return buildModule({pluginId,name:model.definition.permissionModule,routes:buildContentRoutes(model,{pluginId})})});return buildModule({pluginId,name:"content",routes:[],modules,contentTypes:contentTypes.map(model=>model.definition),contentModels:contentTypes,searchIndexers:contentTypes.filter(model=>model.definition.search.enabled).map(model=>model.definition.localization.enabled?createContentLocalizedSearchIndexer(model,{pluginId}):createContentSearchIndexer(model,{pluginId}))})};

package/dist/src/content/server/preview-config.d.ts

@@ -0,0 +1,6 @@
+import type { RegisteredContentType } from "../registry";
+export declare const contentPreviewConfigProblems: () => string[];
+export declare const warnAboutContentPreviewConfig: ({ contentTypes, }: {
+    contentTypes: RegisteredContentType[];
+}) => void;
+//# sourceMappingURL=preview-config.d.ts.map

package/dist/src/content/server/preview-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-config.d.ts","sourceRoot":"","sources":["../../../../src/content/server/preview-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAwBzD,eAAO,MAAM,4BAA4B,QAAO,MAAM,EAOrD,CAAC;AAcF,eAAO,MAAM,6BAA6B,GAAI,mBAE3C;IACD,YAAY,EAAE,qBAAqB,EAAE,CAAC;CACvC,KAAG,IAeH,CAAC"}

package/dist/src/content/server/preview-config.js

@@ -0,0 +1 @@
+import{CONFIG}from"../../lib/config.js";const originProblem=(name,read)=>{try{read();return null}catch{return`${name} is not a valid absolute URL, so preview links cannot be built.`}};export const contentPreviewConfigProblems=()=>{const problems=[originProblem("NEXT_PUBLIC_WEB_URL",()=>CONFIG.web),originProblem("NEXT_PUBLIC_API_URL",()=>CONFIG.api)];return problems.filter(problem=>problem!==null)};export const warnAboutContentPreviewConfig=({contentTypes})=>{const previewable=contentTypes.filter(entry=>entry.definition.editorial.preview.enabled);if(previewable.length===0)return;const problems=contentPreviewConfigProblems();if(problems.length===0)return;const names=previewable.map(entry=>entry.definition.id).join(", ");console.warn(`[Content Engine] ${names} ${previewable.length===1?"has":"have"} \`editorial.preview\` enabled, but preview links cannot be built: ${problems.join(" ")} Preview stays disabled until then.`)};

package/dist/src/content/server/preview-link.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from "hono";
+import type { AnyContentTypeDefinition } from "../types";
+export declare const contentPreviewSecret: (c: Context) => Promise<string>;
+export declare const assertContentPreviewIsServable: () => void;
+export declare const contentPreviewUrl: ({ definition, locale, pluginId, slug, token, }: {
+    definition: AnyContentTypeDefinition;
+    locale?: string;
+    pluginId: string;
+    slug?: null | string;
+    token: string;
+}) => string;
+//# sourceMappingURL=preview-link.d.ts.map

package/dist/src/content/server/preview-link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-link.d.ts","sourceRoot":"","sources":["../../../../src/content/server/preview-link.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAIpC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAmBzD,eAAO,MAAM,oBAAoB,GAAU,GAAG,OAAO,KAAG,OAAO,CAAC,MAAM,CAErB,CAAC;AAUlD,eAAO,MAAM,8BAA8B,QAAO,IAOjD,CAAC;AAoCF,eAAO,MAAM,iBAAiB,GAAI,gDAM/B;IACD,UAAU,EAAE,wBAAwB,CAAC;IAErC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IAQjB,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf,KAAG,MAyCH,CAAC"}

package/dist/src/content/server/preview-link.js

@@ -0,0 +1 @@
+import{HTTPException}from"hono/http-exception";import{CONFIG}from"../../lib/config.js";import{CONTENT_PREVIEW_QUERY_PARAM,CONTENT_PREVIEW_TOKEN_PLACEHOLDER}from"../const.js";import{contentDeliveryPath}from"../delivery.js";import{contentPreviewConfigProblems}from"./preview-config.js";import{ensureContentPreviewSecret}from"./preview-secret.js";export const contentPreviewSecret=async c=>c.get("core")?.contentPreviewSecret??await ensureContentPreviewSecret(c.get("db"));export const assertContentPreviewIsServable=()=>{const problems=contentPreviewConfigProblems();if(problems.length===0)return;throw new HTTPException(503,{message:`Preview is unavailable: ${problems.join(" ")}`})};export const contentPreviewUrl=({definition,locale,pluginId,slug,token})=>{const template=definition.editorial.preview.pathTemplate;if(template){const url=new URL(template.split(CONTENT_PREVIEW_TOKEN_PLACEHOLDER).join(encodeURIComponent(token)),CONFIG.web);if(locale!==undefined&&locale!==""){url.searchParams.set("locale",locale)}return url.toString()}const canonical=definition.delivery.enabled&&slug!==undefined&&slug!==null?contentDeliveryPath({definition,locale,slug}):null;if(canonical!==null){const url=new URL(canonical,CONFIG.web);url.searchParams.set(CONTENT_PREVIEW_QUERY_PARAM,token);return url.toString()}const url=new URL(`/api/${pluginId}/content/${definition.publicApi.path}/preview/${encodeURIComponent(token)}`,CONFIG.api);if(locale!==undefined&&locale!==""){url.searchParams.set("locale",locale)}return url.toString()};

package/dist/src/content/server/preview-secret.d.ts

@@ -0,0 +1,5 @@
+import type { ContentDatabase } from "./service";
+export declare const CONTENT_PREVIEW_SECRET_NAME = "content_preview";
+export declare const ensureContentPreviewSecret: (db: ContentDatabase) => Promise<string>;
+export declare const resetContentPreviewSecret: () => void;
+//# sourceMappingURL=preview-secret.d.ts.map

package/dist/src/content/server/preview-secret.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-secret.d.ts","sourceRoot":"","sources":["../../../../src/content/server/preview-secret.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAKjD,eAAO,MAAM,2BAA2B,oBAAoB,CAAC;AAsE7D,eAAO,MAAM,0BAA0B,GACrC,IAAI,eAAe,KAClB,OAAO,CAAC,MAAM,CAOhB,CAAC;AAGF,eAAO,MAAM,yBAAyB,QAAO,IAE5C,CAAC"}

package/dist/src/content/server/preview-secret.js

@@ -0,0 +1 @@
+import{eq}from"drizzle-orm";import crypto from"node:crypto";import{core_secrets}from"../../database/secrets.js";export const CONTENT_PREVIEW_SECRET_NAME="content_preview";const KEY_BYTES=32;const generate=()=>crypto.randomBytes(KEY_BYTES).toString("base64");const read=async db=>{const[row]=await db.select({value:core_secrets.value}).from(core_secrets).where(eq(core_secrets.name,CONTENT_PREVIEW_SECRET_NAME)).limit(1);return row?.value};const readOrCreate=async db=>{const existing=await read(db);if(existing!==undefined)return existing;const[inserted]=await db.insert(core_secrets).values({name:CONTENT_PREVIEW_SECRET_NAME,value:generate()}).onConflictDoNothing().returning({value:core_secrets.value});if(inserted)return inserted.value;const winner=await read(db);if(winner!==undefined)return winner;throw new Error("Could not read or create the content preview signing secret.")};let cached;export const ensureContentPreviewSecret=async db=>{cached??=readOrCreate(db).catch(error=>{cached=undefined;throw error});return await cached};export const resetContentPreviewSecret=()=>{cached=undefined};

package/dist/src/content/server/preview-target.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from "hono";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentModel } from "./model";
+export interface ContentPreviewTarget {
+    languageId?: number;
+    locale?: string;
+    slug?: string;
+}
+export declare const resolveContentPreviewTarget: <TDefinition extends AnyContentTypeDefinition>(c: Context, model: ContentModel<TDefinition>, { id, row }: {
+    id: number;
+    row: unknown;
+}) => Promise<ContentPreviewTarget>;
+export declare const resolveContentTranslationPreviewSlug: <TDefinition extends AnyContentTypeDefinition>(c: Context, model: ContentModel<TDefinition>, { id, values }: {
+    id: number;
+    values: unknown;
+}) => Promise<string | undefined>;
+//# sourceMappingURL=preview-target.d.ts.map

package/dist/src/content/server/preview-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-target.d.ts","sourceRoot":"","sources":["../../../../src/content/server/preview-target.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAgB5C,MAAM,WAAW,oBAAoB;IAEnC,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAmCD,eAAO,MAAM,2BAA2B,GACtC,WAAW,SAAS,wBAAwB,EAE5C,GAAG,OAAO,EACV,OAAO,YAAY,CAAC,WAAW,CAAC,EAChC,aAAa;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,KACxC,OAAO,CAAC,oBAAoB,CA+B9B,CAAC;AAUF,eAAO,MAAM,oCAAoC,GAC/C,WAAW,SAAS,wBAAwB,EAE5C,GAAG,OAAO,EACV,OAAO,YAAY,CAAC,WAAW,CAAC,EAChC,gBAAgB;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,KAC9C,OAAO,CAAC,MAAM,GAAG,SAAS,CAU5B,CAAC"}

package/dist/src/content/server/preview-target.js

@@ -0,0 +1 @@
+const stringValue=(source,key)=>{if(typeof source!=="object"||source===null)return undefined;const value=source[key];return typeof value==="string"&&value.trim()!==""?value:undefined};const previewSlugField=definition=>definition.delivery.enabled&&definition.publicApi.enabled?definition.publicApi.slugField:"";export const resolveContentPreviewTarget=async(c,model,{id,row})=>{const{definition}=model;const slugField=previewSlugField(definition);if(!definition.localization.enabled){return slugField===""?{}:{slug:stringValue(row,slugField)}}const buildTranslations=model.translationService;if(!buildTranslations)return{};const translation=await buildTranslations(c).findByLocale(id,definition.localization.defaultLocale);if(!translation)return{};const slug=slugField===""?undefined:definition.delivery.slugScope==="shared"?stringValue(row,slugField):stringValue(translation.values,slugField);return{languageId:translation.languageId,locale:translation.locale,slug}};export const resolveContentTranslationPreviewSlug=async(c,model,{id,values})=>{const{definition}=model;const slugField=previewSlugField(definition);if(slugField==="")return undefined;if(definition.delivery.slugScope==="shared"){return stringValue(await model.service(c).findById(id),slugField)}return stringValue(values,slugField)};

package/dist/src/content/server/preview-token.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { AnyContentTypeDefinition } from "../types";
+export declare const zodContentPreviewTokenPayload: z.ZodObject<{
+    aud: z.ZodLiteral<"content-preview">;
+    exp: z.ZodNumber;
+    i: z.ZodNumber;
+    l: z.ZodOptional<z.ZodString>;
+    lid: z.ZodOptional<z.ZodNumber>;
+    p: z.ZodString;
+    r: z.ZodNumber;
+    t: z.ZodString;
+    tr: z.ZodOptional<z.ZodNumber>;
+    v: z.ZodLiteral<1>;
+    ver: z.ZodNumber;
+}, z.core.$strip>;
+export type ContentPreviewTokenPayload = z.infer<typeof zodContentPreviewTokenPayload>;
+export interface ContentPreviewToken {
+    expiresAt: Date;
+    token: string;
+}
+export declare const createContentPreviewToken: ({ definition, itemId, languageId, locale, now, pluginId, revisionId, secret, translationRevisionId, version, }: {
+    definition: AnyContentTypeDefinition;
+    itemId: number;
+    languageId?: number;
+    locale?: string;
+    now?: Date;
+    pluginId: string;
+    revisionId: number;
+    secret: string;
+    translationRevisionId?: number;
+    version: number;
+}) => ContentPreviewToken;
+export declare const verifyContentPreviewToken: ({ definition, locale, now, pluginId, secret, token, }: {
+    definition: AnyContentTypeDefinition;
+    locale?: string;
+    now?: Date;
+    pluginId: string;
+    secret: string;
+    token: string;
+}) => ContentPreviewTokenPayload | null;
+//# sourceMappingURL=preview-token.d.ts.map

package/dist/src/content/server/preview-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-token.d.ts","sourceRoot":"","sources":["../../../../src/content/server/preview-token.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAqBzD,eAAO,MAAM,6BAA6B;;;;;;;;;;;;iBAgCxC,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,6BAA6B,CACrC,CAAC;AAEF,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,IAAI,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AASD,eAAO,MAAM,yBAAyB,GAAI,gHAWvC;IACD,UAAU,EAAE,wBAAwB,CAAC;IACrC,MAAM,EAAE,MAAM,CAAC;IAEf,UAAU,CAAC,EAAE,MAAM,CAAC;IAOpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,IAAI,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IAEjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IAEf,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;CACjB,KAAG,mBAsBH,CAAC;AAgBF,eAAO,MAAM,yBAAyB,GAAI,uDAOvC;IACD,UAAU,EAAE,wBAAwB,CAAC;IAUrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,IAAI,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,KAAG,0BAA0B,GAAG,IAqBhC,CAAC"}

package/dist/src/content/server/preview-token.js

@@ -0,0 +1 @@
+import{z}from"zod";import{signPayload,verifySignedPayload}from"../../lib/api/signed-token.js";import{CONTENT_LOCALE_MAX_LENGTH,CONTENT_PREVIEW_TOKEN_VERSION}from"../const.js";export const zodContentPreviewTokenPayload=z.object({aud:z.literal("content-preview"),exp:z.number().int().positive(),i:z.number().int().positive(),l:z.string().min(1).max(CONTENT_LOCALE_MAX_LENGTH).optional(),lid:z.number().int().positive().optional(),p:z.string().min(1),r:z.number().int().nonnegative(),t:z.string().min(1),tr:z.number().int().nonnegative().optional(),v:z.literal(CONTENT_PREVIEW_TOKEN_VERSION),ver:z.number().int().positive()});export const createContentPreviewToken=({definition,itemId,languageId,locale,now=new Date,pluginId,revisionId,secret,translationRevisionId,version})=>{const expiresAt=new Date(now.getTime()+definition.editorial.preview.expiresInMinutes*6e4);const payload={aud:"content-preview",exp:Math.floor(expiresAt.getTime()/1e3),i:itemId,...locale===undefined?{}:{l:locale,lid:languageId,tr:translationRevisionId??0},p:pluginId,r:revisionId,t:definition.id,v:CONTENT_PREVIEW_TOKEN_VERSION,ver:version};return{expiresAt,token:signPayload(secret,payload)}};export const verifyContentPreviewToken=({definition,locale,now=new Date,pluginId,secret,token})=>{const payload=verifySignedPayload(secret,token,zodContentPreviewTokenPayload);if(!payload)return null;if(payload.p!==pluginId)return null;if(payload.t!==definition.id)return null;if(payload.exp*1e3<=now.getTime())return null;const wanted=locale?.trim().toLowerCase();const minted=payload.l?.trim().toLowerCase();if(wanted!==minted)return null;return payload};

package/dist/src/content/server/public-locales.d.ts

@@ -0,0 +1,9 @@
+import type { Context } from "hono";
+import type { ContentPublicLocaleState } from "../cache";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentModel } from "./model";
+export type { ContentPublicLocaleState };
+export declare const contentPublicLocaleStates: <TDefinition extends AnyContentTypeDefinition>(c: Context, model: ContentModel<TDefinition>, itemId: number, { row }?: {
+    row?: Record<string, unknown>;
+}) => Promise<ContentPublicLocaleState[]>;
+//# sourceMappingURL=public-locales.d.ts.map

package/dist/src/content/server/public-locales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-locales.d.ts","sourceRoot":"","sources":["../../../../src/content/server/public-locales.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAIpC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAO5C,YAAY,EAAE,wBAAwB,EAAE,CAAC;AAkCzC,eAAO,MAAM,yBAAyB,GACpC,WAAW,SAAS,wBAAwB,EAE5C,GAAG,OAAO,EACV,OAAO,YAAY,CAAC,WAAW,CAAC,EAChC,QAAQ,MAAM,EACd,UAAS;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAO,KAC9C,OAAO,CAAC,wBAAwB,EAAE,CA2GpC,CAAC"}

package/dist/src/content/server/public-locales.js

@@ -0,0 +1 @@
+import{eq}from"drizzle-orm";import{isContentPubliclyVisible}from"../cache.js";import{contentLocalesMatch}from"../locale.js";import{partitionContentFields}from"../localization.js";import{listContentLanguages}from"./language-resolver.js";const isVisible=row=>row!==undefined&&isContentPubliclyVisible({publishedAt:row.publishedAt,status:typeof row.status==="string"?row.status:undefined});const asSlug=value=>typeof value==="string"?value:"";export const contentPublicLocaleStates=async(c,model,itemId,{row}={})=>{const{definition}=model;const{localization,publicApi}=definition;if(!localization.enabled||!publicApi.enabled)return[];const translationColumns=model.translationColumns;const translationTable=model.translationTable;if(!translationColumns||!translationTable)return[];const columns=model.columns;const table=model.table;const slugField=publicApi.slugField;const{localizedFields}=partitionContentFields(definition.fields);const slugIsLocalized=localizedFields[slugField]!==undefined;const base=row??(await c.get("db").select({publishedAt:columns.publishedAt,status:columns.status,...slugIsLocalized?{}:{[slugField]:columns[slugField]}}).from(table).where(eq(columns.id,itemId)).limit(1))[0];if(!base)return[];const baseRow=base;const basePublic=isVisible(baseRow);const sharedSlug=slugIsLocalized?"":asSlug(baseRow[slugField]);const rows=await c.get("db").select({languageId:translationColumns.languageId,publishedAt:translationColumns.publishedAt,status:translationColumns.status,...slugIsLocalized?{[slugField]:translationColumns[slugField]}:{}}).from(translationTable).where(eq(translationColumns.itemId,itemId));const byLanguage=new Map(rows.map(entry=>[entry.languageId,entry]));const languages=(await listContentLanguages(c)).filter(language=>language.isEnabled);const defaultLanguage=languages.find(language=>contentLocalesMatch(language.locale,localization.defaultLocale));const defaultTranslation=defaultLanguage===undefined?undefined:byLanguage.get(defaultLanguage.id);const defaultIsPublic=basePublic&&isVisible(defaultTranslation);const slugOf=translation=>slugIsLocalized?asSlug(translation?.[slugField]):sharedSlug;return languages.map(language=>{const own=byLanguage.get(language.id);const ownIsPublic=basePublic&&isVisible(own);if(ownIsPublic){return{hasOwnTranslation:true,isPublic:true,locale:language.locale,slug:slugOf(own)}}if(localization.fallback==="default"&&defaultIsPublic){return{hasOwnTranslation:false,isPublic:true,locale:language.locale,slug:slugOf(defaultTranslation)}}return{hasOwnTranslation:false,isPublic:false,locale:language.locale,slug:slugOf(own)}})};

package/dist/src/content/server/public-module.d.ts

@@ -0,0 +1,7 @@
+import type { BuildModuleReturn } from "../../api/lib/module";
+import type { AnyContentModel } from "./model";
+export declare const buildContentPublicModule: <P extends string>({ contentTypes, pluginId, }: {
+    contentTypes: AnyContentModel[];
+    pluginId: P;
+}) => BuildModuleReturn<P, "content">;
+//# sourceMappingURL=public-module.d.ts.map

package/dist/src/content/server/public-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-module.d.ts","sourceRoot":"","sources":["../../../../src/content/server/public-module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAiC/C,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,MAAM,EAAE,6BAGxD;IACD,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,QAAQ,EAAE,CAAC,CAAC;CACb,KAAG,iBAAiB,CAAC,CAAC,EAAE,SAAS,CAkBjC,CAAC"}

package/dist/src/content/server/public-module.js

@@ -0,0 +1 @@
+import{buildModule}from"../../api/lib/module.js";import{buildContentPublicRoutes}from"./public-routes.js";export const buildContentPublicModule=({contentTypes,pluginId})=>{const modules=contentTypes.filter(model=>model.definition.publicApi.enabled).map(model=>buildModule({pluginId,name:model.definition.publicApi.path,routes:buildContentPublicRoutes(model,{pluginId})}));return buildModule({pluginId,name:"content",routes:[],modules})};

package/dist/src/content/server/public-routes.d.ts

@@ -0,0 +1,261 @@
+import { z } from "@hono/zod-openapi";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentModel } from "./model";
+export declare const buildContentPublicRoutes: <TDefinition extends AnyContentTypeDefinition, P extends string>(model: ContentModel<TDefinition>, { pluginId }: {
+    pluginId: P;
+}) => (import("../../api/lib/route").Route<P, {
+    method: "get";
+    path: "/";
+    description: string;
+    request: {
+        query: z.ZodObject<{
+            [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        } | {
+            [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        edges: z.ZodArray<z.ZodObject<Readonly<{
+                            [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                        }>, z.core.$strip>>;
+                        pageInfo: z.ZodObject<{
+                            totalCount: z.ZodNumber;
+                            count: z.ZodNumber;
+                            hasNextPage: z.ZodBoolean;
+                            hasPreviousPage: z.ZodBoolean;
+                            startCursor: z.ZodNullable<z.ZodString>;
+                            endCursor: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "get";
+    path: "/preview/{token}";
+    description: string;
+    request: {
+        query?: z.ZodObject<{
+            locale: z.ZodOptional<z.ZodString>;
+        } | {
+            locale?: undefined;
+        }, z.core.$strip> | undefined;
+        params: z.ZodObject<{
+            token: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<Readonly<{
+                        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                    }>, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        404: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "get";
+    path: "/delivery/resolve/{slug}";
+    description: string;
+    request: {
+        query?: z.ZodObject<{
+            locale: z.ZodOptional<z.ZodString>;
+        } | {
+            locale?: undefined;
+        }, z.core.$strip> | undefined;
+        params: z.ZodObject<{
+            slug: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        alternates: z.ZodArray<z.ZodObject<{
+                            locale: z.ZodString;
+                            path: z.ZodString;
+                        }, z.core.$strip>>;
+                        canonicalPath: z.ZodNullable<z.ZodString>;
+                        hreflang: z.ZodObject<{
+                            languages: z.ZodRecord<z.ZodString, z.ZodString>;
+                            xDefault: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                        isFallback: z.ZodBoolean;
+                        itemId: z.ZodNullable<z.ZodNumber>;
+                        locale: z.ZodNullable<z.ZodString>;
+                        openGraph: z.ZodNullable<z.ZodObject<{
+                            description: z.ZodNullable<z.ZodString>;
+                            title: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>>;
+                        requestedLocale: z.ZodNullable<z.ZodString>;
+                        robots: z.ZodNullable<z.ZodObject<{
+                            follow: z.ZodBoolean;
+                            index: z.ZodBoolean;
+                        }, z.core.$strip>>;
+                        seo: z.ZodObject<{
+                            description: z.ZodNullable<z.ZodString>;
+                            title: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>;
+                        type: z.ZodLiteral<"content">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        location: z.ZodString;
+                        status: z.ZodLiteral<308>;
+                        type: z.ZodLiteral<"redirect">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"not_found">;
+                    }, z.core.$strip>], "type">;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "get";
+    path: "/delivery/item/{id}";
+    description: string;
+    request: {
+        query?: z.ZodObject<{
+            locale: z.ZodOptional<z.ZodString>;
+        } | {
+            locale?: undefined;
+        }, z.core.$strip> | undefined;
+        params: z.ZodObject<{
+            id: z.ZodCoercedNumber<unknown>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        alternates: z.ZodArray<z.ZodObject<{
+                            locale: z.ZodString;
+                            path: z.ZodString;
+                        }, z.core.$strip>>;
+                        canonicalPath: z.ZodNullable<z.ZodString>;
+                        hreflang: z.ZodObject<{
+                            languages: z.ZodRecord<z.ZodString, z.ZodString>;
+                            xDefault: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                        isFallback: z.ZodBoolean;
+                        itemId: z.ZodNullable<z.ZodNumber>;
+                        locale: z.ZodNullable<z.ZodString>;
+                        openGraph: z.ZodNullable<z.ZodObject<{
+                            description: z.ZodNullable<z.ZodString>;
+                            title: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>>;
+                        requestedLocale: z.ZodNullable<z.ZodString>;
+                        robots: z.ZodNullable<z.ZodObject<{
+                            follow: z.ZodBoolean;
+                            index: z.ZodBoolean;
+                        }, z.core.$strip>>;
+                        seo: z.ZodObject<{
+                            description: z.ZodNullable<z.ZodString>;
+                            title: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        404: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "get";
+    path: "/delivery/sitemap";
+    description: string;
+    request: {
+        query: z.ZodObject<{
+            cursor: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            locale: z.ZodOptional<z.ZodString>;
+        } | {
+            cursor: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            locale?: undefined;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        entries: z.ZodArray<z.ZodObject<{
+                            changeFrequency: z.ZodNullable<z.ZodString>;
+                            itemId: z.ZodNumber;
+                            lastModified: z.ZodString;
+                            locale: z.ZodNullable<z.ZodString>;
+                            path: z.ZodString;
+                            priority: z.ZodNullable<z.ZodNumber>;
+                        }, z.core.$strip>>;
+                        nextCursor: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "get";
+    path: "/{slug}";
+    description: string;
+    request: {
+        query?: z.ZodObject<{
+            locale: z.ZodOptional<z.ZodString>;
+        } | {
+            locale?: undefined;
+        }, z.core.$strip> | undefined;
+        params: z.ZodObject<{
+            slug: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<Readonly<{
+                        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                    }>, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        404: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>)[];
+//# sourceMappingURL=public-routes.d.ts.map

package/dist/src/content/server/public-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-routes.d.ts","sourceRoot":"","sources":["../../../../src/content/server/public-routes.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAItC,OAAO,KAAK,EACV,wBAAwB,EAGzB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAsD5C,eAAO,MAAM,wBAAwB,GACnC,WAAW,SAAS,wBAAwB,EAC5C,CAAC,SAAS,MAAM,EAEhB,OAAO,YAAY,CAAC,WAAW,CAAC,EAChC,cAAc;IAAE,QAAQ,EAAE,CAAC,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmc9B,CAAC"}

package/dist/src/content/server/public-routes.js

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{and,eq}from"drizzle-orm";import{HTTPException}from"hono/http-exception";import{buildRoute}from"../../api/lib/route.js";import{zodPaginationPageInfo,zodPaginationQuery}from"../../api/lib/with-pagination.js";import{contentTypeName}from"../admin/labels.js";import{CONTENT_LOCALE_MAX_LENGTH,CONTENT_PUBLIC_MAX_PAGE_SIZE}from"../const.js";import{ContentEngineError}from"../errors.js";import{resolveContentPublicLocale}from"../locale.js";import{partitionContentFields}from"../localization.js";import{contentColumnsToValues,contentStorageColumns,splitContentFieldPath}from"../paths.js";import{publicOrderableColumns}from"../registry.js";import{buildContentDeliveryRoutes}from"./delivery-routes.js";import{resolveContentPublicRowFiles}from"./files.js";import{findContentLanguage,listContentLanguages}from"./language-resolver.js";import{contentPreviewSecret}from"./preview-link.js";import{verifyContentPreviewToken}from"./preview-token.js";import{contentPublicSelection,createContentPublicProjector}from"./public-service.js";import{contentSnapshotRow,projectTranslationRevisionSnapshot}from"./revision-snapshot.js";export const buildContentPublicRoutes=(model,{pluginId})=>{const{definition,schemas}=model;const name=contentTypeName(definition.id);const service=c=>{const build=model.publicService;if(!build){throw new ContentEngineError("This content type has no public API, so it should not have a public route either.",{contentTypeId:definition.id})}return build(c)};const localized=definition.localization.enabled;const orderable=publicOrderableColumns(definition);const localeQuery=localized?{locale:z.string().min(1).max(CONTENT_LOCALE_MAX_LENGTH).optional()}:{};const paginationQuery=zodPaginationQuery.extend({...localeQuery,order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(orderable).optional(),search:z.string().optional()});const listQuery=paginationQuery.extend(schemas.publicFilters.shape);const localeOnlyQuery=z.object(localeQuery);const notFound=()=>new HTTPException(404,{message:`${name} not found.`});const project=createContentPublicProjector(definition);const localeFor=async c=>{if(!localized)return{locale:undefined,source:"default"};const languages=await listContentLanguages(c);return resolveContentPublicLocale({acceptLanguage:c.req.header("accept-language"),available:languages.filter(language=>language.isEnabled).map(language=>language.locale),defaultLocale:definition.localization.defaultLocale,explicit:c.req.query("locale")})};const localeHeaders=(locale,source)=>{if(locale===undefined)return{};return{"Content-Language":locale,...source==="negotiated"?{Vary:"Accept-Language"}:{}}};const table=model.table;const translationTable=model.translationTable;const readPreviewRow=async(c,payload)=>{if(payload.r>0){const build=model.editorialService;if(!build)return null;const revision=await build(c,{pluginId}).revisions.findById(payload.i,payload.r);return revision?contentSnapshotRow(revision.snapshot):null}const[row]=await c.get("db").select(contentPublicSelection(definition,model.columns)).from(table).where(eq(model.columns.id,payload.i)).limit(1);return row??null};const readPreviewTranslation=async(c,payload)=>{const locale=payload.l;if(locale===undefined)return null;const language=await findContentLanguage(c,locale);if(!language)return null;const translationColumns=model.translationColumns;if(!translationColumns||!translationTable)return null;if(payload.tr&&payload.tr>0){const build=model.translationEditorialService;if(!build)return null;const revision=await build(c,{pluginId}).findRevision(payload.i,language.locale,payload.tr);return revision?projectTranslationRevisionSnapshot(definition,revision.snapshot):null}const{localizedFields}=partitionContentFields(definition.fields);const exposedLocalized=definition.publicApi.fields.filter(name=>{const path=splitContentFieldPath(name);return localizedFields[path?path[0]:name]!==undefined});const localizedColumns=contentStorageColumns(Object.fromEntries([...new Set(exposedLocalized.map(name=>splitContentFieldPath(name)?.[0]??name))].map(name=>[name,localizedFields[name]])));const[row]=await c.get("db").select(Object.fromEntries(Object.keys(localizedColumns).map(name=>[name,translationColumns[name]]))).from(translationTable).where(and(eq(translationColumns.itemId,payload.i),eq(translationColumns.languageId,language.id))).limit(1);return row?{...row,...contentColumnsToValues(localizedFields,row)}:null};const list=buildRoute({pluginId,route:{method:"get",path:"/",description:`List published ${name} records`,request:{query:listQuery},responses:{200:{content:{"application/json":{schema:z.object({edges:z.array(schemas.publicSelectObject),pageInfo:zodPaginationPageInfo})}},description:`Up to ${CONTENT_PUBLIC_MAX_PAGE_SIZE} published ${name} records`},400:{description:"Invalid query parameters"}}},handler:async c=>{const raw=c.req.query();const{cursor,first,last,order,orderBy,search}=paginationQuery.parse(raw);const filters=schemas.publicFilters.parse(raw);const resolved=await localeFor(c);if(!resolved)throw notFound();const data=await service(c).findMany({filters,locale:resolved.locale,orderBy:{column:orderBy,order},query:{cursor,first,last,search}});return c.json(data,200,localeHeaders(resolved.locale,resolved.source))}});const preview=buildRoute({pluginId,route:{method:"get",path:"/preview/{token}",description:`Read one ${name} from a signed preview link`,request:{params:z.object({token:z.string()}),...localized?{query:localeOnlyQuery}:{}},responses:{200:{content:{"application/json":{schema:schemas.publicSelectObject}},description:`${name} as the link's revision recorded it`},404:{description:"No such preview"}}},handler:async c=>{const secret=await contentPreviewSecret(c);const resolved=await localeFor(c);if(!resolved)throw notFound();const payload=verifyContentPreviewToken({definition,locale:resolved.locale,pluginId,secret,token:c.req.param("token")});if(!payload)throw notFound();const row=await readPreviewRow(c,payload);if(!row)throw notFound();const translated=localized?await readPreviewTranslation(c,payload):null;if(localized&&!translated)throw notFound();const[withFiles]=await resolveContentPublicRowFiles(c,definition,[{...row,...translated}]);return c.json({...project(withFiles),...localized?{locale:resolved.locale}:{}},200,{"Cache-Control":"private, no-store","X-Robots-Tag":"noindex, nofollow",...localeHeaders(resolved.locale,resolved.source)})}});const detail=buildRoute({pluginId,route:{method:"get",path:"/{slug}",description:`Get one published ${name} by slug`,request:{params:schemas.publicParams,...localized?{query:localeOnlyQuery}:{}},responses:{200:{content:{"application/json":{schema:schemas.publicSelectObject}},description:`${name} found`},404:{description:`${name} not found`}}},handler:async c=>{const resolved=await localeFor(c);if(!resolved)throw notFound();const row=await service(c).findBySlug(c.req.param("slug"),{locale:resolved.locale});if(!row)throw notFound();return c.json(row,200,localeHeaders(resolved.locale,resolved.source))}});return[list,...definition.editorial.preview.enabled?[preview]:[],...definition.delivery.enabled?buildContentDeliveryRoutes(model,{pluginId}):[],detail]};