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

package/dist/src/content/server/collection-api.d.ts

@@ -0,0 +1,44 @@
+import type { AnyContentTypeDefinition } from "../types";
+export type ContentCollectionRunner<TResult, TOptions> = (itemId: number, field: string, compute: (current: unknown[]) => unknown[], options: TOptions | undefined) => Promise<null | TResult>;
+export type ContentCollectionReader = (itemId: number, field: string, options: unknown) => Promise<unknown[]>;
+export type ContentCollectionWriter<TResult, TOptions> = (itemId: number, field: string, next: readonly unknown[], options: TOptions | undefined) => Promise<null | TResult>;
+export interface ContentCollectionApi<TResult, TOptions> {
+    read: ContentCollectionReader;
+    run: ContentCollectionRunner<TResult, TOptions>;
+    write: ContentCollectionWriter<TResult, TOptions>;
+}
+export declare const assertContentPermutation: ({ contentTypeId, current, field, next, noun, }: {
+    contentTypeId: string;
+    current: readonly number[];
+    field: string;
+    next: readonly number[];
+    noun: string;
+}) => void;
+export declare const buildContentRelationOperations: <TResult, TOptions>({ api, contentTypeId, field, }: {
+    api: ContentCollectionApi<TResult, TOptions>;
+    contentTypeId: string;
+    field: string;
+}) => {
+    add: (itemId: number, relatedItemId: number, options?: TOptions) => Promise<null | TResult>;
+    get: (itemId: number, options?: unknown) => Promise<number[]>;
+    remove: (itemId: number, relatedItemId: number, options?: TOptions) => Promise<null | TResult>;
+    reorder: (itemId: number, relatedItemIds: readonly number[], options?: TOptions) => Promise<null | TResult>;
+    set: (itemId: number, relatedItemIds: readonly number[], options?: TOptions) => Promise<null | TResult>;
+};
+export declare const buildContentRepeatableOperations: <TResult, TOptions>({ api, contentTypeId, field, }: {
+    api: ContentCollectionApi<TResult, TOptions>;
+    contentTypeId: string;
+    field: string;
+}) => {
+    create: (itemId: number, values: Record<string, unknown>, options?: TOptions) => Promise<null | TResult>;
+    delete: (itemId: number, childId: number, options?: TOptions) => Promise<null | TResult>;
+    list: (itemId: number, options?: unknown) => Promise<Record<string, unknown>[]>;
+    reorder: (itemId: number, childIds: readonly number[], options?: TOptions) => Promise<null | TResult>;
+    set: (itemId: number, rows: readonly Record<string, unknown>[], options?: TOptions) => Promise<null | TResult>;
+    update: (itemId: number, childId: number, values: Record<string, unknown>, options?: TOptions) => Promise<null | TResult>;
+};
+export declare const contentCollectionKinds: (definition: AnyContentTypeDefinition, fields: readonly string[]) => {
+    relations: string[];
+    repeatables: string[];
+};
+//# sourceMappingURL=collection-api.d.ts.map

package/dist/src/content/server/collection-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-api.d.ts","sourceRoot":"","sources":["../../../../src/content/server/collection-api.ts"],"names":[],"mappings":"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"}

package/dist/src/content/server/collection-api.js

@@ -0,0 +1 @@
+import{ContentEngineError}from"../errors.js";export const assertContentPermutation=({contentTypeId,current,field,next,noun})=>{const before=[...current].sort((a,b)=>a-b);const after=[...new Set(next)].sort((a,b)=>a-b);const same=before.length===after.length&&before.every((id,index)=>id===after[index]);if(same&&next.length===new Set(next).size)return;throw new ContentEngineError(`Reorder of "${field}" must list exactly the ${noun} ids it already has, once each. Use \`set\` to add or remove.`,{contentTypeId})};const asNumbers=current=>current.map(value=>Number(value)).filter(value=>Number.isInteger(value));const asRows=current=>current.filter(value=>typeof value==="object"&&value!==null);export const buildContentRelationOperations=({api,contentTypeId,field})=>({add:async(itemId,relatedItemId,options)=>await api.run(itemId,field,current=>{const ids=asNumbers(current);return ids.includes(relatedItemId)?ids:[...ids,relatedItemId]},options),get:async(itemId,options)=>asNumbers(await api.read(itemId,field,options)),remove:async(itemId,relatedItemId,options)=>await api.run(itemId,field,current=>asNumbers(current).filter(id=>id!==relatedItemId),options),reorder:async(itemId,relatedItemIds,options)=>await api.run(itemId,field,current=>{assertContentPermutation({contentTypeId,current:asNumbers(current),field,next:relatedItemIds,noun:"target"});return[...relatedItemIds]},options),set:async(itemId,relatedItemIds,options)=>await api.write(itemId,field,relatedItemIds,options)});export const buildContentRepeatableOperations=({api,contentTypeId,field})=>({create:async(itemId,values,options)=>await api.run(itemId,field,current=>[...asRows(current),values],options),delete:async(itemId,childId,options)=>await api.run(itemId,field,current=>asRows(current).filter(row=>row.id!==childId),options),list:async(itemId,options)=>asRows(await api.read(itemId,field,options)),reorder:async(itemId,childIds,options)=>await api.run(itemId,field,current=>{const rows=asRows(current);assertContentPermutation({contentTypeId,current:rows.map(row=>Number(row.id)),field,next:childIds,noun:"entry"});const byId=new Map(rows.map(row=>[Number(row.id),row]));return childIds.map(childId=>byId.get(childId)??{})},options),set:async(itemId,rows,options)=>await api.write(itemId,field,rows,options),update:async(itemId,childId,values,options)=>await api.run(itemId,field,current=>asRows(current).map(row=>Number(row.id)===childId?{...row,...values,id:childId}:row),options)});export const contentCollectionKinds=(definition,fields)=>{const relations=[];const repeatables=[];for(const field of fields){if(definition.fields[field]?.kind==="repeatable"){repeatables.push(field);continue}relations.push(field)}return{relations,repeatables}};

package/dist/src/content/server/column-builders.d.ts

@@ -0,0 +1,19 @@
+import type { AnyPgColumn, AnyPgColumnBuilder } from "drizzle-orm/pg-core";
+import type { ContentFieldDescriptor } from "../types";
+export type ColumnReferenceThunk = () => AnyPgColumn;
+export declare const buildSystemColumns: () => Record<string, AnyPgColumnBuilder>;
+export declare const buildPublicationColumns: () => Record<string, AnyPgColumnBuilder>;
+export declare const buildEditorialColumns: () => Record<string, AnyPgColumnBuilder>;
+export declare const buildTranslationSystemColumns: ({ itemReference, languageReference, onItemDelete, }: {
+    itemReference: ColumnReferenceThunk;
+    languageReference: ColumnReferenceThunk;
+    onItemDelete?: "cascade";
+}) => Record<string, AnyPgColumnBuilder>;
+export declare const buildTranslationPublicationColumns: () => Record<string, AnyPgColumnBuilder>;
+export declare const buildContentColumn: ({ contentTypeId, fieldValue, name, reference, }: {
+    contentTypeId: string;
+    fieldValue: ContentFieldDescriptor;
+    name: string;
+    reference?: ColumnReferenceThunk;
+}) => AnyPgColumnBuilder;
+//# sourceMappingURL=column-builders.d.ts.map

package/dist/src/content/server/column-builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-builders.d.ts","sourceRoot":"","sources":["../../../../src/content/server/column-builders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAY3E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAWvD,MAAM,MAAM,oBAAoB,GAAG,MAAM,WAAW,CAAC;AAOrD,eAAO,MAAM,kBAAkB,QAAO,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAOrE,CAAC;AAaH,eAAO,MAAM,uBAAuB,QAAO,MAAM,CAC/C,MAAM,EACN,kBAAkB,CASlB,CAAC;AAaH,eAAO,MAAM,qBAAqB,QAAO,MAAM,CAC7C,MAAM,EACN,kBAAkB,CAGlB,CAAC;AAeH,eAAO,MAAM,6BAA6B,GAAI,qDAI3C;IACD,aAAa,EAAE,oBAAoB,CAAC;IACpC,iBAAiB,EAAE,oBAAoB,CAAC;IACxC,YAAY,CAAC,EAAE,SAAS,CAAC;CAC1B,KAAG,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAuBnC,CAAC;AAYH,eAAO,MAAM,kCAAkC,QAAO,MAAM,CAC1D,MAAM,EACN,kBAAkB,CACU,CAAC;AA8B/B,eAAO,MAAM,kBAAkB,GAAI,iDAKhC;IACD,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,sBAAsB,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,oBAAoB,CAAC;CAClC,KAAG,kBA2GH,CAAC"}

package/dist/src/content/server/column-builders.js

@@ -0,0 +1 @@
+import{boolean,doublePrecision,integer,serial,text,timestamp,varchar}from"drizzle-orm/pg-core";import{CONTENT_ENUM_DEFAULT_LENGTH,CONTENT_PUBLICATION_STATUS_LENGTH,CONTENT_PUBLICATION_STATUSES,CONTENT_SLUG_DEFAULT_LENGTH,CONTENT_TEXT_DEFAULT_LENGTH}from"../const.js";import{ContentEngineError}from"../errors.js";export const buildSystemColumns=()=>({id:serial().primaryKey(),createdAt:timestamp().notNull().defaultNow(),updatedAt:timestamp().notNull().defaultNow().$onUpdate(()=>new Date)});export const buildPublicationColumns=()=>({publishedAt:timestamp(),status:varchar({enum:CONTENT_PUBLICATION_STATUSES,length:CONTENT_PUBLICATION_STATUS_LENGTH}).notNull().default("draft")});export const buildEditorialColumns=()=>({version:integer().notNull().default(1)});export const buildTranslationSystemColumns=({itemReference,languageReference,onItemDelete="cascade"})=>({itemId:integer().notNull().references(itemReference,{onDelete:onItemDelete,onUpdate:"cascade"}),languageId:integer().notNull().references(languageReference,{onDelete:"restrict",onUpdate:"cascade"}),version:integer().notNull().default(1),createdAt:timestamp().notNull().defaultNow(),updatedAt:timestamp().notNull().defaultNow().$onUpdate(()=>new Date)});export const buildTranslationPublicationColumns=()=>buildPublicationColumns();const withModifiers=(builder,{defaultValue,nullable})=>{const withNull=nullable?builder:builder.notNull();return defaultValue===undefined?withNull:withNull.default(defaultValue)};export const buildContentColumn=({contentTypeId,fieldValue,name,reference})=>{const{nullable}=fieldValue;if(fieldValue.kind==="group"||fieldValue.kind==="repeatable"){throw new ContentEngineError(`Field "${name}" is a ${fieldValue.kind} and has no column of its own. Flatten the field map with \`contentStorageColumns\` before building columns from it.`,{contentTypeId})}if((fieldValue.kind==="relation"||fieldValue.kind==="user")&&fieldValue.multiple){throw new ContentEngineError(`Field "${name}" is a to-many ${fieldValue.kind==="user"?"user field":"relation"}, whose values live in a generated junction table rather than in a column.`,{contentTypeId})}switch(fieldValue.kind){case"boolean":return withModifiers(boolean(),{defaultValue:fieldValue.defaultValue,nullable});case"dateTime":{const column=nullable?timestamp():timestamp().notNull();return fieldValue.defaultNow?column.defaultNow():column}case"enum":return withModifiers(varchar({enum:fieldValue.values,length:fieldValue.length??CONTENT_ENUM_DEFAULT_LENGTH}),{defaultValue:fieldValue.defaultValue,nullable});case"file":{if(!reference){throw new ContentEngineError(`Field "${name}" is a file reference but the \`core_files\` column was not resolved. This is an internal error.`,{contentTypeId})}const column=integer().references(reference,{onDelete:"restrict",onUpdate:"cascade"});return nullable?column:column.notNull()}case"number":return withModifiers(fieldValue.integer?integer():doublePrecision(),{defaultValue:fieldValue.defaultValue,nullable});case"relation":case"user":{if(!reference){throw new ContentEngineError(`Field "${name}" is a ${fieldValue.kind} reference but no target column was resolved.`,{contentTypeId})}const column=integer().references(reference,{onDelete:fieldValue.onDelete,onUpdate:"cascade"});return nullable?column:column.notNull()}case"slug":return varchar({length:fieldValue.maxLength??CONTENT_SLUG_DEFAULT_LENGTH}).notNull();case"text":return withModifiers(varchar({length:fieldValue.maxLength??CONTENT_TEXT_DEFAULT_LENGTH}),{defaultValue:fieldValue.defaultValue,nullable});case"textarea":return withModifiers(text(),{defaultValue:fieldValue.defaultValue,nullable})}};

package/dist/src/content/server/delivery-alternates.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from "hono";
+import type { ContentDeliveryAlternate } from "../delivery";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentModel } from "./model";
+import type { ContentDatabase } from "./service";
+export declare const readDeliveryAlternates: <TDefinition extends AnyContentTypeDefinition>({ c, itemId, model, }: {
+    c: Context;
+    itemId: number;
+    model: ContentModel<TDefinition>;
+}) => Promise<ContentDeliveryAlternate[]>;
+export declare const readDeliveryAlternatesMany: <TDefinition extends AnyContentTypeDefinition>({ c, database, itemIds, model, }: {
+    c: Context;
+    database?: ContentDatabase;
+    itemIds: readonly number[];
+    model: ContentModel<TDefinition>;
+}) => Promise<Map<number, ContentDeliveryAlternate[]>>;
+//# sourceMappingURL=delivery-alternates.d.ts.map

package/dist/src/content/server/delivery-alternates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-alternates.d.ts","sourceRoot":"","sources":["../../../../src/content/server/delivery-alternates.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAIpC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AA4BjD,eAAO,MAAM,sBAAsB,GACjC,WAAW,SAAS,wBAAwB,EAC5C,uBAIC;IACD,CAAC,EAAE,OAAO,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;CAClC,KAAG,OAAO,CAAC,wBAAwB,EAAE,CAQrC,CAAC;AASF,eAAO,MAAM,0BAA0B,GACrC,WAAW,SAAS,wBAAwB,EAC5C,kCAKC;IACD,CAAC,EAAE,OAAO,CAAC;IACX,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,KAAK,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;CAClC,KAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,wBAAwB,EAAE,CAAC,CAyFlD,CAAC"}

package/dist/src/content/server/delivery-alternates.js

@@ -0,0 +1 @@
+import{and,asc,eq,inArray}from"drizzle-orm";import{contentDeliveryPath}from"../delivery.js";import{listContentLanguages}from"./language-resolver.js";import{contentTranslationPublicationColumns,publicationColumns,publishedCondition}from"./publication.js";export const readDeliveryAlternates=async({c,itemId,model})=>{const batched=await readDeliveryAlternatesMany({c,itemIds:[itemId],model});return batched.get(itemId)??[]};export const readDeliveryAlternatesMany=async({c,database,itemIds,model})=>{const{columns,definition,translationColumns,translationTable}=model;const grouped=new Map;if(itemIds.length===0||!definition.localization.enabled||!definition.publicApi.enabled||!translationTable||!translationColumns){return grouped}const slugField=definition.publicApi.slugField;const base=publicationColumns(definition,columns);const translation=contentTranslationPublicationColumns(definition,translationColumns);const slugColumn=definition.delivery.slugScope==="localized"?translationColumns[slugField]:columns[slugField];const languages=await listContentLanguages(c);const byId=new Map(languages.map(language=>[language.id,language]));const baseTable=model.table;const rows=await (database??c.get("db")).select({itemId:translationColumns.itemId,languageId:translationColumns.languageId,slug:slugColumn}).from(translationTable).innerJoin(baseTable,eq(translationColumns.itemId,columns.id)).where(and(inArray(translationColumns.itemId,[...itemIds]),publishedCondition(base),publishedCondition(translation))).orderBy(asc(translationColumns.itemId),asc(translationColumns.languageId));for(const row of rows){const itemId=typeof row.itemId==="number"?row.itemId:null;const languageId=typeof row.languageId==="number"?row.languageId:null;if(itemId===null||languageId===null)continue;const language=byId.get(languageId);if(!language?.isEnabled)continue;const path=contentDeliveryPath({definition,locale:language.locale,slug:typeof row.slug==="string"?row.slug:""});if(path===null)continue;const entries=grouped.get(itemId)??[];entries.push({locale:language.locale,path});grouped.set(itemId,entries)}for(const entries of grouped.values()){entries.sort((a,b)=>a.locale.localeCompare(b.locale))}return grouped};

package/dist/src/content/server/delivery-effects.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from "hono";
+import type { EventEmitResult } from "../../api/models/events";
+import type { ContentDeliveryInvalidation } from "../cache";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentDeliveryOutcome } from "./delivery-writes";
+export interface ContentDeliveryEffectsResult {
+    events: EventEmitResult[];
+}
+export declare const contentDeliveryEffects: (c: Context, definition: AnyContentTypeDefinition, delivery: ContentDeliveryOutcome | undefined, { pluginId }: {
+    pluginId: string;
+}) => Promise<ContentDeliveryEffectsResult>;
+export declare const contentDeliveryInvalidation: (definition: AnyContentTypeDefinition, delivery: ContentDeliveryOutcome | undefined) => ContentDeliveryInvalidation | undefined;
+//# sourceMappingURL=delivery-effects.d.ts.map

package/dist/src/content/server/delivery-effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-effects.d.ts","sourceRoot":"","sources":["../../../../src/content/server/delivery-effects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAKhE,MAAM,WAAW,4BAA4B;IAS3C,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AA0BD,eAAO,MAAM,sBAAsB,GACjC,GAAG,OAAO,EACV,YAAY,wBAAwB,EACpC,UAAU,sBAAsB,GAAG,SAAS,EAC5C,cAAc;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,KACjC,OAAO,CAAC,4BAA4B,CAuFtC,CAAC;AAUF,eAAO,MAAM,2BAA2B,GACtC,YAAY,wBAAwB,EACpC,UAAU,sBAAsB,GAAG,SAAS,KAC3C,2BAA2B,GAAG,SAahC,CAAC"}

package/dist/src/content/server/delivery-effects.js

@@ -0,0 +1 @@
+import{reportContentEventFailures}from"./effects-log.js";import{emitContentEvent}from"./emit.js";export const contentDeliveryEffects=async(c,definition,delivery,{pluginId})=>{const events=[];const announce=async(action,payload,{itemId,locale})=>{const event=await emitContentEvent(c,definition,action,payload,{pluginId});events.push(event);await reportContentEventFailures(c,{action,contentTypeId:definition.id,event,itemId,...locale===null?{}:{locale}})};if(delivery===undefined||!delivery.slugChanged||delivery.canonicalPath===null){return{events}}await announce("delivery_slug_changed",{canonicalPath:delivery.canonicalPath,contentId:delivery.itemId,locale:delivery.locale,previousPath:delivery.previousPath,previousSlug:delivery.previousSlug,slug:delivery.slug},{itemId:delivery.itemId,locale:delivery.locale});if(delivery.redirectCreated&&delivery.previousPath!==null&&delivery.previousSlug!==null){await announce("delivery_redirect_created",{canonicalPath:delivery.canonicalPath,contentId:delivery.itemId,locale:delivery.locale,previousPath:delivery.previousPath,previousSlug:delivery.previousSlug},{itemId:delivery.itemId,locale:delivery.locale})}return{events}};export const contentDeliveryInvalidation=(definition,delivery)=>{if(!definition.delivery.enabled)return undefined;return{sitemap:delivery?.sitemap??{contentChanged:false,indexChanged:false}}};

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

@@ -0,0 +1,161 @@
+import { z } from "@hono/zod-openapi";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentModel } from "./model";
+export declare const buildContentDeliveryRoutes: <TDefinition extends AnyContentTypeDefinition, P extends string>(model: ContentModel<TDefinition>, { pluginId }: {
+    pluginId: P;
+}) => (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;
+}>)[];
+//# sourceMappingURL=delivery-routes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-routes.d.ts","sourceRoot":"","sources":["../../../../src/content/server/delivery-routes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAGtC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAsC5C,eAAO,MAAM,0BAA0B,GACrC,WAAW,SAAS,wBAAwB,EAC5C,CAAC,SAAS,MAAM,EAEhB,OAAO,YAAY,CAAC,WAAW,CAAC,EAChC,cAAc;IAAE,QAAQ,EAAE,CAAC,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAyO9B,CAAC"}

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

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{HTTPException}from"hono/http-exception";import{buildRoute}from"../../api/lib/route.js";import{contentTypeName}from"../admin/labels.js";import{CONTENT_DELIVERY_REDIRECT_STATUS,CONTENT_LOCALE_MAX_LENGTH,CONTENT_SITEMAP_DEFAULT_PAGE_SIZE,CONTENT_SITEMAP_MAX_URLS}from"../const.js";import{ContentDeliveryNotEnabled}from"../errors.js";import{resolveContentPublicLocale}from"../locale.js";import{listContentLanguages}from"./language-resolver.js";export const buildContentDeliveryRoutes=(model,{pluginId})=>{const{definition}=model;const name=contentTypeName(definition.id);const localized=definition.localization.enabled;const service=c=>{const build=model.deliveryService;if(!build)throw new ContentDeliveryNotEnabled({contentTypeId:definition.id});return build(c,{pluginId})};const localeQuery=localized?{locale:z.string().min(1).max(CONTENT_LOCALE_MAX_LENGTH).optional()}:{};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 zodAlternate=z.object({locale:z.string(),path:z.string()});const zodSeo=z.object({description:z.string().nullable(),title:z.string().nullable()});const zodMetadata=z.object({alternates:z.array(zodAlternate),canonicalPath:z.string().nullable(),hreflang:z.object({languages:z.record(z.string(),z.string()),xDefault:z.string().optional()}),isFallback:z.boolean(),itemId:z.number().int().nullable(),locale:z.string().nullable(),openGraph:zodSeo.nullable(),requestedLocale:z.string().nullable(),robots:z.object({follow:z.boolean(),index:z.boolean()}).nullable(),seo:zodSeo});const zodResolution=z.discriminatedUnion("type",[zodMetadata.extend({type:z.literal("content")}),z.object({location:z.string(),status:z.literal(CONTENT_DELIVERY_REDIRECT_STATUS),type:z.literal("redirect")}),z.object({type:z.literal("not_found")})]);const zodSitemapEntry=z.object({changeFrequency:z.string().nullable(),itemId:z.number().int(),lastModified:z.string(),locale:z.string().nullable(),path:z.string(),priority:z.number().nullable()});const sitemapQuery=z.object({...localeQuery,cursor:z.coerce.number().int().positive().optional(),limit:z.coerce.number().int().min(1).max(CONTENT_SITEMAP_MAX_URLS).optional()});const resolve=buildRoute({pluginId,route:{method:"get",path:"/delivery/resolve/{slug}",description:`Resolve one ${name} URL to its canonical form, a redirect, or nothing`,request:{params:z.object({slug:z.string()}),...localized?{query:z.object(localeQuery)}:{}},responses:{200:{content:{"application/json":{schema:zodResolution}},description:"The resolution. A `not_found` is a 200 with a body, not a 404"}}},handler:async c=>{const resolved=await localeFor(c);if(!resolved)return c.json({type:"not_found"},200);const resolution=await service(c).resolveSlug(c.req.param("slug"),{locale:resolved.locale});return c.json(resolution,200)}});const item=buildRoute({pluginId,route:{method:"get",path:"/delivery/item/{id}",description:`Delivery metadata for one published ${name}`,request:{params:z.object({id:z.coerce.number().int().positive()}),...localized?{query:z.object(localeQuery)}:{}},responses:{200:{content:{"application/json":{schema:zodMetadata}},description:`Canonical URL, alternates and SEO metadata`},404:{description:`${name} not found`}}},handler:async c=>{const resolved=await localeFor(c);if(!resolved)throw notFound(name);const id=Number(c.req.param("id"));const metadata=await service(c).findById(id,{locale:resolved.locale});if(!metadata)throw notFound(name);return c.json(metadata,200)}});const sitemap=buildRoute({pluginId,route:{method:"get",path:"/delivery/sitemap",description:`One page of the ${name} sitemap`,request:{query:sitemapQuery},responses:{200:{content:{"application/json":{schema:z.object({entries:z.array(zodSitemapEntry),nextCursor:z.number().int().nullable()})}},description:`Up to ${CONTENT_SITEMAP_MAX_URLS} public URLs, oldest record first`},400:{description:"Invalid query parameters"}}},handler:async c=>{const{cursor,limit}=sitemapQuery.parse(c.req.query());const resolved=await localeFor(c);if(!resolved)return c.json({entries:[],nextCursor:null},200);const page=await service(c).sitemap({cursor,limit:limit??CONTENT_SITEMAP_DEFAULT_PAGE_SIZE,locale:resolved.locale});return c.json({entries:page.entries.map(entry=>({...entry,lastModified:entry.lastModified.toISOString()})),nextCursor:page.nextCursor},200)}});return[resolve,item,...definition.delivery.sitemap.enabled?[sitemap]:[]]};const notFound=singular=>new HTTPException(404,{message:`${singular} not found.`});

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

@@ -0,0 +1,57 @@
+import type { Context } from "hono";
+import type { ContentDeliveryAlternate, ContentDeliveryHreflang, ContentDeliveryRobots, ContentDeliverySeo } from "../delivery";
+import type { ContentSitemapEntry } from "../sitemap";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentDeliverySitemapPage } from "./delivery-sitemap";
+import type { ContentModel } from "./model";
+import type { ContentSlugHistoryEntry } from "./slug-history-model";
+export interface ContentDeliveryMetadata {
+    alternates: ContentDeliveryAlternate[];
+    canonicalPath: null | string;
+    canonicalUrl?: null | string;
+    hreflang: ContentDeliveryHreflang;
+    isFallback: boolean;
+    itemId: null | number;
+    locale: null | string;
+    openGraph: ContentDeliverySeo | null;
+    requestedLocale: null | string;
+    robots: ContentDeliveryRobots | null;
+    seo: ContentDeliverySeo;
+}
+export type ContentDeliveryResolution = (ContentDeliveryMetadata & {
+    type: "content";
+}) | {
+    location: string;
+    status: 308;
+    type: "redirect";
+} | {
+    type: "not_found";
+};
+export interface ContentDeliveryReadOptions {
+    locale?: string;
+    origin?: string;
+}
+export interface ContentDeliverySitemapArgs {
+    cursor?: number;
+    limit?: number;
+    locale?: string;
+}
+export interface ContentDeliveryService {
+    alternates: (itemId: number) => Promise<ContentDeliveryAlternate[]>;
+    findById: (itemId: number, options?: ContentDeliveryReadOptions) => Promise<ContentDeliveryMetadata | null>;
+    history: (itemId: number, options?: {
+        locale?: string;
+    }) => Promise<ContentSlugHistoryEntry[]>;
+    resolvePath: (path: string, options?: {
+        origin?: string;
+    }) => Promise<ContentDeliveryResolution>;
+    resolveSlug: (slug: string, options?: ContentDeliveryReadOptions) => Promise<ContentDeliveryResolution>;
+    sitemap: (args?: ContentDeliverySitemapArgs) => Promise<ContentDeliverySitemapPage>;
+}
+export declare const createContentDeliveryService: <TDefinition extends AnyContentTypeDefinition>({ c, model, pluginId, }: {
+    c: Context;
+    model: ContentModel<TDefinition>;
+    pluginId: string;
+}) => ContentDeliveryService;
+export type { ContentSitemapEntry };
+//# sourceMappingURL=delivery-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-service.d.ts","sourceRoot":"","sources":["../../../../src/content/server/delivery-service.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1 @@
+import{CONTENT_DELIVERY_REDIRECT_STATUS}from"../const.js";import{contentDeliveryHreflang,contentDeliveryOpenGraph,contentDeliveryPath,contentDeliveryRobots,contentDeliverySeo,contentDeliveryUrl,parseContentDeliveryPath}from"../delivery.js";import{ContentDeliveryNotEnabled}from"../errors.js";import{contentLocalesMatch,normalizeContentLocale}from"../locale.js";import{readDeliveryAlternates}from"./delivery-alternates.js";import{readContentDeliverySitemapPage}from"./delivery-sitemap.js";import{findContentLanguage}from"./language-resolver.js";import{createContentSlugHistoryModel}from"./slug-history-model.js";const slugOf=(definition,row)=>{const value=row[definition.publicApi.slugField];return typeof value==="string"&&value!==""?value:null};const localeOf=(definition,row)=>{if(!definition.localization.enabled)return null;return typeof row.locale==="string"?row.locale:null};export const createContentDeliveryService=({c,model,pluginId})=>{const{definition}=model;const contentTypeId=definition.id;if(!definition.delivery.enabled||!definition.publicApi.enabled){throw new ContentDeliveryNotEnabled({contentTypeId})}const localized=definition.localization.enabled;const buildPublic=model.publicService;if(!buildPublic)throw new ContentDeliveryNotEnabled({contentTypeId});const slugHistory=createContentSlugHistoryModel({c,definition,pluginId});const historyLanguageId=async locale=>{if(definition.delivery.slugScope!=="localized"||locale===null){return null}const language=await findContentLanguage(c,locale);return language?.id??null};const metadataFor=async(row,{itemId,origin,requestedLocale})=>{const locale=localeOf(definition,row);const slug=slugOf(definition,row);const canonicalPath=slug===null?null:contentDeliveryPath({definition,locale,slug});const alternates=localized&&itemId!==null?await readAlternates(itemId):[];return{alternates,canonicalPath,...origin===undefined?{}:{canonicalUrl:contentDeliveryUrl({origin,path:canonicalPath})},hreflang:contentDeliveryHreflang({alternates,definition}),isFallback:requestedLocale!==null&&locale!==null&&!contentLocalesMatch(requestedLocale,locale),itemId,locale,openGraph:contentDeliveryOpenGraph(definition,row),requestedLocale,robots:contentDeliveryRobots(definition,row),seo:contentDeliverySeo(definition,row)}};const readAlternates=async itemId=>localized?await readDeliveryAlternates({c,itemId,model}):[];const strictCanonicalPath=async(itemId,locale)=>{const row=await buildPublic(c).findById(itemId,{locale:locale??undefined});if(!row)return null;const values=row;const served=localeOf(definition,values);if(locale!==null&&served!==null&&!contentLocalesMatch(locale,served)){return null}const slug=slugOf(definition,values);return slug===null?null:contentDeliveryPath({definition,locale:served,slug})};const localeFor=locale=>{if(!localized)return null;return normalizeContentLocale(locale??definition.localization.defaultLocale)};const resolve=async(slug,{locale,origin}={})=>{const requestedLocale=localeFor(locale);const row=await buildPublic(c).findBySlug(slug,{locale});if(row){const values=row;return{...await metadataFor(values,{itemId:typeof values.id==="number"?values.id:null,origin,requestedLocale}),type:"content"}}if(!definition.delivery.redirects.enabled)return{type:"not_found"};const languageId=await historyLanguageId(requestedLocale);const owner=await slugHistory.owner({languageId,slug});if(!owner)return{type:"not_found"};const destination=await strictCanonicalPath(owner.itemId,requestedLocale);if(destination===null||destination===owner.path){return{type:"not_found"}}return{location:destination,status:CONTENT_DELIVERY_REDIRECT_STATUS,type:"redirect"}};return{alternates:async itemId=>await readAlternates(itemId),findById:async(itemId,{locale,origin}={})=>{const row=await buildPublic(c).findById(itemId,{locale});if(!row)return null;return await metadataFor(row,{itemId,origin,requestedLocale:localeFor(locale)})},history:async(itemId,{locale}={})=>{const languageId=await historyLanguageId(locale===undefined?null:normalizeContentLocale(locale));return await slugHistory.list({itemId,languageId:definition.delivery.slugScope==="localized"&&locale===undefined?undefined:languageId})},resolvePath:async(path,{origin}={})=>{const parts=parseContentDeliveryPath(definition,path);if(!parts)return{type:"not_found"};return await resolve(parts.slug,{locale:parts.locale??undefined,origin})},resolveSlug:async(slug,options)=>await resolve(slug,options),sitemap:async(args={})=>await readContentDeliverySitemapPage({args,c,model})}};

package/dist/src/content/server/delivery-sitemap.d.ts

@@ -0,0 +1,15 @@
+import type { Context } from "hono";
+import type { ContentSitemapEntry } from "../sitemap";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentDeliverySitemapArgs } from "./delivery-service";
+import type { ContentModel } from "./model";
+export interface ContentDeliverySitemapPage {
+    entries: ContentSitemapEntry[];
+    nextCursor: null | number;
+}
+export declare const readContentDeliverySitemapPage: <TDefinition extends AnyContentTypeDefinition>({ args, c, model, }: {
+    args: ContentDeliverySitemapArgs;
+    c: Context;
+    model: ContentModel<TDefinition>;
+}) => Promise<ContentDeliverySitemapPage>;
+//# sourceMappingURL=delivery-sitemap.d.ts.map

package/dist/src/content/server/delivery-sitemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-sitemap.d.ts","sourceRoot":"","sources":["../../../../src/content/server/delivery-sitemap.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAIpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAyB5C,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,mBAAmB,EAAE,CAAC;IAE/B,UAAU,EAAE,IAAI,GAAG,MAAM,CAAC;CAC3B;AAgDD,eAAO,MAAM,8BAA8B,GACzC,WAAW,SAAS,wBAAwB,EAC5C,qBAIC;IACD,IAAI,EAAE,0BAA0B,CAAC;IACjC,CAAC,EAAE,OAAO,CAAC;IACX,KAAK,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;CAClC,KAAG,OAAO,CAAC,0BAA0B,CAuJrC,CAAC"}

package/dist/src/content/server/delivery-sitemap.js

@@ -0,0 +1 @@
+import{and,asc,eq,gt,sql}from"drizzle-orm";import{CONTENT_SITEMAP_DEFAULT_PAGE_SIZE,CONTENT_SITEMAP_MAX_URLS}from"../const.js";import{contentDeliveryPath}from"../delivery.js";import{ContentDeliveryNotEnabled}from"../errors.js";import{splitContentFieldPath}from"../paths.js";import{findContentLanguage}from"./language-resolver.js";import{contentTranslationPublicationColumns,publicationColumns,publishedCondition}from"./publication.js";const noIndexColumn=(definition,columns)=>{const{noIndexField}=definition.delivery.seo;if(noIndexField===null)return null;const path=splitContentFieldPath(noIndexField);if(!path)return columns[noIndexField]??null;const leaf=definition.advanced.leaves.find(entry=>entry.path===noIndexField);return leaf===undefined?null:columns[leaf.columnName]??null};export const readContentDeliverySitemapPage=async({args,c,model})=>{const{columns,definition,translationColumns}=model;const{sitemap}=definition.delivery;if(!definition.delivery.enabled||!definition.publicApi.enabled){throw new ContentDeliveryNotEnabled({contentTypeId:definition.id})}if(!sitemap.enabled)return{entries:[],nextCursor:null};const limit=Math.max(1,Math.min(args.limit??CONTENT_SITEMAP_DEFAULT_PAGE_SIZE,CONTENT_SITEMAP_MAX_URLS));const slugField=definition.publicApi.slugField;const base=publicationColumns(definition,columns);const exclude=noIndexColumn(definition,columns);const localized=definition.localization.enabled;const baseTable=model.table;const joinedTranslations=model.translationTable;const conditions=[publishedCondition(base),args.cursor===undefined?undefined:gt(columns.id,args.cursor),exclude===null?undefined:sql`${exclude} is distinct from true`];if(!localized){const rows=await c.get("db").select({itemId:columns.id,lastModified:columns.updatedAt,slug:columns[slugField]}).from(baseTable).where(and(...conditions.filter(part=>part!==undefined))).orderBy(asc(columns.id)).limit(limit+1);return page({definition,limit,locale:null,rows:rows.map(row=>({itemId:row.itemId,lastModified:row.lastModified,slug:row.slug}))})}if(!joinedTranslations||!translationColumns){return{entries:[],nextCursor:null}}const language=await findContentLanguage(c,args.locale??definition.localization.defaultLocale);if(!language?.isEnabled)return{entries:[],nextCursor:null};const translation=contentTranslationPublicationColumns(definition,translationColumns);const slugColumn=definition.delivery.slugScope==="localized"?translationColumns[slugField]:columns[slugField];const rows=await c.get("db").select({itemId:columns.id,lastModified:sql`greatest(${columns.updatedAt}, ${translationColumns.updatedAt})`.mapWith(columns.updatedAt),slug:slugColumn}).from(baseTable).innerJoin(joinedTranslations,and(eq(translationColumns.itemId,columns.id),eq(translationColumns.languageId,language.id))).where(and(...conditions.filter(part=>part!==undefined),publishedCondition(translation))).orderBy(asc(columns.id)).limit(limit+1);return page({definition,limit,locale:language.locale,rows:rows.map(row=>({itemId:row.itemId,lastModified:row.lastModified instanceof Date?row.lastModified:new Date(String(row.lastModified)),slug:row.slug}))})};const page=({definition,limit,locale,rows})=>{const visible=rows.slice(0,limit);const{sitemap}=definition.delivery;const entries=[];for(const row of visible){const path=contentDeliveryPath({definition,locale,slug:typeof row.slug==="string"?row.slug:""});if(path===null)continue;entries.push({changeFrequency:sitemap.changeFrequency,itemId:row.itemId,lastModified:row.lastModified,locale,path,priority:sitemap.priority})}return{entries,nextCursor:rows.length>limit?visible.at(-1)?.itemId??null:null}};

package/dist/src/content/server/delivery-writes.d.ts

@@ -0,0 +1,37 @@
+import type { Context } from "hono";
+import type { ContentSitemapChange } from "../cache";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentDatabase } from "./service";
+import type { ContentSlugHistoryModel } from "./slug-history-model";
+export interface ContentDeliveryOutcome {
+    canonicalPath: null | string;
+    itemId: number;
+    locale: null | string;
+    previousPath: null | string;
+    previousSlug: null | string;
+    redirectCreated: boolean;
+    sitemap: ContentSitemapChange;
+    slug: null | string;
+    slugChanged: boolean;
+}
+export interface ContentDeliveryTransition {
+    isPublic: boolean;
+    itemId: number;
+    languageId: null | number;
+    locale: null | string;
+    previousSlug: null | string;
+    slug: null | string;
+    wasPublic: boolean;
+}
+export declare const applyContentDeliveryWrite: ({ definition, slugHistory, transition, tx, }: {
+    definition: AnyContentTypeDefinition;
+    slugHistory: ContentSlugHistoryModel | null;
+    transition: ContentDeliveryTransition;
+    tx: ContentDatabase;
+}) => Promise<ContentDeliveryOutcome>;
+export declare const contentSlugHistoryFor: ({ c, definition, pluginId, }: {
+    c: Context;
+    definition: AnyContentTypeDefinition;
+    pluginId: string;
+}) => ContentSlugHistoryModel | null;
+//# sourceMappingURL=delivery-writes.d.ts.map

package/dist/src/content/server/delivery-writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-writes.d.ts","sourceRoot":"","sources":["../../../../src/content/server/delivery-writes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAiBpE,MAAM,WAAW,sBAAsB;IAErC,aAAa,EAAE,IAAI,GAAG,MAAM,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IAEf,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC;IAEtB,YAAY,EAAE,IAAI,GAAG,MAAM,CAAC;IAC5B,YAAY,EAAE,IAAI,GAAG,MAAM,CAAC;IAQ5B,eAAe,EAAE,OAAO,CAAC;IASzB,OAAO,EAAE,oBAAoB,CAAC;IAE9B,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC;IAEpB,WAAW,EAAE,OAAO,CAAC;CACtB;AASD,MAAM,WAAW,yBAAyB;IAExC,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IAEf,UAAU,EAAE,IAAI,GAAG,MAAM,CAAC;IAE1B,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC;IACtB,YAAY,EAAE,IAAI,GAAG,MAAM,CAAC;IAC5B,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC;IAEpB,SAAS,EAAE,OAAO,CAAC;CACpB;AAuBD,eAAO,MAAM,yBAAyB,GAAU,8CAK7C;IACD,UAAU,EAAE,wBAAwB,CAAC;IAErC,WAAW,EAAE,uBAAuB,GAAG,IAAI,CAAC;IAC5C,UAAU,EAAE,yBAAyB,CAAC;IACtC,EAAE,EAAE,eAAe,CAAC;CACrB,KAAG,OAAO,CAAC,sBAAsB,CA+HjC,CAAC;AAGF,eAAO,MAAM,qBAAqB,GAAI,8BAInC;IACD,CAAC,EAAE,OAAO,CAAC;IACX,UAAU,EAAE,wBAAwB,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB,KAAG,uBAAuB,GAAG,IAGpB,CAAC"}

package/dist/src/content/server/delivery-writes.js

@@ -0,0 +1 @@
+import{contentDeliveryPath}from"../delivery.js";import{createContentSlugHistoryModel}from"./slug-history-model.js";export const applyContentDeliveryWrite=async({definition,slugHistory,transition,tx})=>{const{isPublic,itemId,languageId,locale,previousSlug,slug,wasPublic}=transition;const pathFor=value=>value===null?null:contentDeliveryPath({definition,locale,slug:value});const canonicalPath=pathFor(slug);const previousPath=pathFor(previousSlug);const slugChanged=previousSlug!==null&&slug!==null&&previousSlug!==slug;let redirectCreated=false;if(slugHistory!==null){const leavingService=slugChanged||slug===null||!isPublic;if(wasPublic&&previousSlug!==null&&previousPath!==null&&leavingService){await slugHistory.ensureCurrent(tx,{itemId,languageId,locale,path:previousPath,slug:previousSlug})}if(slugChanged&&previousSlug!==null){const{retired}=await slugHistory.retire(tx,{itemId,languageId,slug:previousSlug});redirectCreated=retired}if(isPublic&&slug!==null&&canonicalPath!==null){await slugHistory.reserve(tx,{itemId,languageId,locale,path:canonicalPath,slug})}else if(slug!==null&&slug!==previousSlug){await slugHistory.assertAvailable(tx,{itemId,languageId,locale,slug})}}return{canonicalPath,itemId,locale,previousPath:slugChanged?previousPath:null,previousSlug:slugChanged?previousSlug:null,redirectCreated,sitemap:{contentChanged:wasPublic||isPublic,indexChanged:wasPublic!==isPublic},slug,slugChanged}};export const contentSlugHistoryFor=({c,definition,pluginId})=>definition.delivery.enabled&&definition.delivery.redirects.enabled?createContentSlugHistoryModel({c,definition,pluginId}):null;

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

@@ -0,0 +1,56 @@
+import type { Context } from "hono";
+import type { RegisteredContentModel } from "./model";
+export interface ContentSearchDriftLocale {
+    canonicalHealthy: boolean;
+    canonicalIndexed: number;
+    expected: number;
+    locale: string;
+    providerHealthy: boolean | null;
+    providerIndexed: null | number;
+}
+export interface ContentSearchDriftProvider {
+    error?: string;
+    healthy: boolean | null;
+    indexedTotal: null | number;
+    name: string;
+    verified: boolean;
+}
+export interface ContentSearchDrift {
+    canonicalHealthy: boolean;
+    canonicalIndexedTotal: number;
+    contentTypeId: string;
+    expectedTotal: number;
+    healthy: boolean;
+    locales: ContentSearchDriftLocale[];
+    provider: ContentSearchDriftProvider;
+}
+export declare const contentSearchDrift: (c: Context, { model }: Pick<RegisteredContentModel, "model">) => Promise<ContentSearchDrift>;
+export declare const CONTENT_DIAGNOSTICS_LOG_PREFIX = "[content-diagnostics]";
+export interface ContentScheduleHealth {
+    failedEffects: number;
+    pending: number;
+    withErrors: number;
+}
+export declare const contentScheduleHealth: (c: Context, contentTypeIds: readonly string[]) => Promise<Map<string, ContentScheduleHealth>>;
+export interface ContentTypeDiagnostic {
+    contentTypeId: string;
+    features: {
+        editorial: boolean;
+        localization: boolean;
+        publicApi: boolean;
+        publication: boolean;
+        scheduling: boolean;
+        search: boolean;
+    };
+    pluginId: string;
+    schedules: ContentScheduleHealth | null;
+    search: ContentSearchDrift | null;
+}
+export interface ContentEngineDiagnostics {
+    contentTypes: ContentTypeDiagnostic[];
+    effectsHealthy: boolean;
+    healthy: boolean;
+    searchHealthy: boolean;
+}
+export declare const contentEngineDiagnostics: (c: Context) => Promise<ContentEngineDiagnostics>;
+//# sourceMappingURL=diagnostics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../../src/content/server/diagnostics.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAIpC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAqCtD,MAAM,WAAW,wBAAwB;IASvC,gBAAgB,EAAE,OAAO,CAAC;IAE1B,gBAAgB,EAAE,MAAM,CAAC;IAEzB,QAAQ,EAAE,MAAM,CAAC;IAQjB,MAAM,EAAE,MAAM,CAAC;IASf,eAAe,EAAE,OAAO,GAAG,IAAI,CAAC;IAEhC,eAAe,EAAE,IAAI,GAAG,MAAM,CAAC;CAChC;AAGD,MAAM,WAAW,0BAA0B;IAEzC,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAYxB,YAAY,EAAE,IAAI,GAAG,MAAM,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IAQb,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IAEjC,gBAAgB,EAAE,OAAO,CAAC;IAE1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IAEtB,aAAa,EAAE,MAAM,CAAC;IAQtB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,wBAAwB,EAAE,CAAC;IACpC,QAAQ,EAAE,0BAA0B,CAAC;CACtC;AAyBD,eAAO,MAAM,kBAAkB,GAC7B,GAAG,OAAO,EACV,WAAW,IAAI,CAAC,sBAAsB,EAAE,OAAO,CAAC,KAC/C,OAAO,CAAC,kBAAkB,CA0F5B,CAAC;AAmGF,eAAO,MAAM,8BAA8B,0BAA0B,CAAC;AAsFtE,MAAM,WAAW,qBAAqB;IAQpC,aAAa,EAAE,MAAM,CAAC;IAEtB,OAAO,EAAE,MAAM,CAAC;IAEhB,UAAU,EAAE,MAAM,CAAC;CACpB;AAQD,eAAO,MAAM,qBAAqB,GAChC,GAAG,OAAO,EACV,gBAAgB,SAAS,MAAM,EAAE,KAChC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAyB5C,CAAC;AAEF,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE;QACR,SAAS,EAAE,OAAO,CAAC;QACnB,YAAY,EAAE,OAAO,CAAC;QACtB,SAAS,EAAE,OAAO,CAAC;QACnB,WAAW,EAAE,OAAO,CAAC;QACrB,UAAU,EAAE,OAAO,CAAC;QACpB,MAAM,EAAE,OAAO,CAAC;KACjB,CAAC;IACF,QAAQ,EAAE,MAAM,CAAC;IAEjB,SAAS,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAExC,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,wBAAwB;IACvC,YAAY,EAAE,qBAAqB,EAAE,CAAC;IAUtC,cAAc,EAAE,OAAO,CAAC;IAQxB,OAAO,EAAE,OAAO,CAAC;IAQjB,aAAa,EAAE,OAAO,CAAC;CACxB;AAQD,eAAO,MAAM,wBAAwB,GACnC,GAAG,OAAO,KACT,OAAO,CAAC,wBAAwB,CAmDlC,CAAC"}

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

@@ -0,0 +1 @@
+import{and,count,eq,inArray,sql}from"drizzle-orm";import{core_content_schedules}from"../../database/content.js";import{core_search_index}from"../../database/search.js";import{normalizeContentLocale}from"../locale.js";import{listContentLanguages}from"./language-resolver.js";import{contentDefinitionOf}from"./model.js";import{contentTranslationPublicationColumns,publicationColumns,publishedCondition}from"./publication.js";export const contentSearchDrift=async(c,{model})=>{const definition=contentDefinitionOf(model);const contentTypeId=definition.id;const indexedRows=await c.get("db").select({documents:count(),languageCode:core_search_index.languageCode}).from(core_search_index).where(eq(core_search_index.itemType,contentTypeId)).groupBy(core_search_index.languageCode);const indexedByLocale=new Map(indexedRows.map(row=>[normalizeContentLocale(row.languageCode),row.documents]));const expectedByLocale=await expectedDocuments(c,model);const keys=[...new Set([...expectedByLocale.keys(),...indexedByLocale.keys()])].sort();const sum=values=>{let total=0;for(const value of values)total+=value;return total};const expectedTotal=sum(expectedByLocale.values());const canonicalIndexedTotal=sum(indexedByLocale.values());const provider=await providerCounts(c,{canonicalTotal:canonicalIndexedTotal,contentTypeId,locales:keys});const locales=keys.map(locale=>{const expected=expectedByLocale.get(locale)??0;const canonicalIndexed=indexedByLocale.get(locale)??0;const providerIndexed=provider.canonical?canonicalIndexed:provider.byLocale.get(locale)??null;return{canonicalHealthy:expected===canonicalIndexed,canonicalIndexed,expected,locale,providerHealthy:providerIndexed===null?null:providerIndexed===expected,providerIndexed}});const canonicalHealthy=canonicalIndexedTotal===expectedTotal&&locales.every(entry=>entry.canonicalHealthy);const providerHealthy=provider.verified?provider.error===undefined&&provider.total===expectedTotal&&locales.every(entry=>entry.providerHealthy===true):null;return{canonicalHealthy,canonicalIndexedTotal,contentTypeId,expectedTotal,healthy:canonicalHealthy&&providerHealthy===true,locales,provider:{...provider.error===undefined?{}:{error:provider.error},healthy:providerHealthy,indexedTotal:provider.total,name:provider.name,verified:provider.verified}}};const providerCounts=async(c,{canonicalTotal,contentTypeId,locales})=>{const search=c.get("search");const name=search.name();if(search.isCanonicalStorage()){return{byLocale:new Map,canonical:true,name,total:canonicalTotal,verified:true}}const unverified={byLocale:new Map,canonical:false,name,total:null,verified:false};const byLocale=new Map;try{const total=await search.countDocuments({itemType:contentTypeId});if(total===null)return unverified;for(const locale of locales){const counted=await search.countDocuments({itemType:contentTypeId,languageCode:locale});if(counted===null)return unverified;byLocale.set(locale,counted)}return{byLocale,canonical:false,name,total,verified:true}}catch(error){const message=error instanceof Error?error.message:"unknown error";await logDiagnosticFailure(c,`${CONTENT_DIAGNOSTICS_LOG_PREFIX} ${JSON.stringify({contentTypeId,error:message,provider:name})}`);return{byLocale:new Map,canonical:false,error:message,name,total:null,verified:true}}};export const CONTENT_DIAGNOSTICS_LOG_PREFIX="[content-diagnostics]";const logDiagnosticFailure=async(c,message)=>{try{await c.get("log").error(message)}catch{console.error(`[VitNode] ${message}`)}};const expectedDocuments=async(c,model)=>{const definition=contentDefinitionOf(model);const columns=model.columns;if(!definition.publication.enabled)return new Map;const published=publicationColumns(definition,columns);if(!definition.localization.enabled){const[row]=await c.get("db").select({value:count()}).from(model.table).where(publishedCondition(published));return new Map([["",row?.value??0]])}const translationTable=model.translationTable;const translationColumns=model.translationColumns;if(!translationTable||!translationColumns)return new Map;const translation=contentTranslationPublicationColumns(definition,translationColumns);const rows=await c.get("db").select({languageId:translationColumns.languageId,value:count()}).from(translationTable).innerJoin(model.table,eq(translationColumns.itemId,columns.id)).where(and(publishedCondition(published),publishedCondition(translation))).groupBy(translationColumns.languageId);const languages=await listContentLanguages(c);const localeOf=new Map(languages.map(language=>[language.id,language.locale]));const byLocale=new Map;for(const row of rows){const locale=localeOf.get(row.languageId);if(locale===undefined)continue;const key=normalizeContentLocale(locale);byLocale.set(key,(byLocale.get(key)??0)+row.value)}return byLocale};export const contentScheduleHealth=async(c,contentTypeIds)=>{const result=new Map;if(contentTypeIds.length===0)return result;const rows=await c.get("db").select({contentTypeId:core_content_schedules.contentTypeId,failedEffects:sql`count(*) filter (where ${core_content_schedules.effectsError} is not null)::int`,pending:sql`count(*) filter (where ${core_content_schedules.status} = 'pending')::int`,withErrors:sql`count(*) filter (where ${core_content_schedules.status} = 'pending' and ${core_content_schedules.lastError} is not null)::int`}).from(core_content_schedules).where(inArray(core_content_schedules.contentTypeId,[...contentTypeIds])).groupBy(core_content_schedules.contentTypeId);for(const row of rows){result.set(row.contentTypeId,{failedEffects:row.failedEffects,pending:row.pending,withErrors:row.withErrors})}return result};export const contentEngineDiagnostics=async c=>{const registered=[...c.get("core")?.contentModels??[]].sort((a,b)=>a.model.definition.id.localeCompare(b.model.definition.id));const schedulable=registered.filter(entry=>entry.model.definition.editorial.scheduling.enabled).map(entry=>entry.model.definition.id);const schedules=await contentScheduleHealth(c,schedulable);const contentTypes=[];for(const entry of registered){const definition=contentDefinitionOf(entry.model);contentTypes.push({contentTypeId:definition.id,features:{editorial:definition.editorial.enabled,localization:definition.localization.enabled,publicApi:definition.publicApi.enabled,publication:definition.publication.enabled,scheduling:definition.editorial.scheduling.enabled,search:definition.search.enabled},pluginId:entry.pluginId,search:definition.search.enabled?await contentSearchDrift(c,entry):null,schedules:definition.editorial.scheduling.enabled?schedules.get(definition.id)??{failedEffects:0,pending:0,withErrors:0}:null})}const searchHealthy=contentTypes.every(entry=>entry.search===null||entry.search.healthy);const effectsHealthy=contentTypes.every(entry=>(entry.schedules?.failedEffects??0)===0);return{contentTypes,effectsHealthy,healthy:searchHealthy&&effectsHealthy,searchHealthy}};

package/dist/src/content/server/editorial-effects.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from "hono";
+import type { EventEmitResult } from "../../api/models/events";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentDeliveryEffectsResult } from "./delivery-effects";
+import type { ContentEditorialOutcome } from "./editorial-service";
+import type { AnyContentModel } from "./model";
+import type { ContentSearchSyncOutcome } from "./search-sync";
+export interface ContentEditorialEffectsOptions {
+    model?: AnyContentModel;
+    pluginId: string;
+    scheduledBy?: null | number;
+    scheduleId?: number;
+}
+export interface ContentEditorialEffectsResult {
+    delivery?: ContentDeliveryEffectsResult;
+    event: EventEmitResult | null;
+    search: ContentSearchSyncOutcome | null;
+    searchByLocale?: ContentSearchSyncOutcome[];
+}
+export declare const contentEditorialEffects: (c: Context, definition: AnyContentTypeDefinition, outcome: ContentEditorialOutcome<AnyContentTypeDefinition>, { model, pluginId, scheduledBy, scheduleId }: ContentEditorialEffectsOptions) => Promise<ContentEditorialEffectsResult>;
+//# sourceMappingURL=editorial-effects.d.ts.map

package/dist/src/content/server/editorial-effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editorial-effects.d.ts","sourceRoot":"","sources":["../../../../src/content/server/editorial-effects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAkE9D,MAAM,WAAW,8BAA8B;IAU7C,KAAK,CAAC,EAAE,eAAe,CAAC;IAExB,QAAQ,EAAE,MAAM,CAAC;IAQjB,WAAW,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAQ5B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,6BAA6B;IAM5C,QAAQ,CAAC,EAAE,4BAA4B,CAAC;IAUxC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAC9B,MAAM,EAAE,wBAAwB,GAAG,IAAI,CAAC;IAKxC,cAAc,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC7C;AAuBD,eAAO,MAAM,uBAAuB,GAClC,GAAG,OAAO,EACV,YAAY,wBAAwB,EACpC,SAAS,uBAAuB,CAAC,wBAAwB,CAAC,EAC1D,8CAA8C,8BAA8B,KAC3E,OAAO,CAAC,6BAA6B,CAqFvC,CAAC"}

package/dist/src/content/server/editorial-effects.js

@@ -0,0 +1 @@
+import{contentDeliveryEffects}from"./delivery-effects.js";import{reportContentEventFailures}from"./effects-log.js";import{emitContentEvent}from"./emit.js";import{contentSearchAdvancedValues,syncContentLocalizedSearch,syncContentSearch}from"./search-sync.js";const EVENT_ACTION={create:"created",delete:"deleted",publish:"published",restore:"restored",unpublish:"unpublished",update:"updated"};const payloadFor=(outcome,{scheduledBy,scheduleId})=>{const base={contentId:outcome.row.id,revisionId:outcome.revisionId??undefined,...scheduledBy===undefined?{}:{scheduledBy},...scheduleId===undefined?{}:{scheduleId},version:outcome.version};switch(outcome.operation){case"publish":{const publishedAt=outcome.row.publishedAt;return publishedAt instanceof Date?{...base,publishedAt}:{...base}}case"restore":return{...base,changedFields:outcome.changedFields,restoredFromRevisionId:outcome.restoredFromRevisionId};case"update":return{...base,changedFields:outcome.changedFields};default:return base}};export const contentEditorialEffects=async(c,definition,outcome,{model,pluginId,scheduledBy,scheduleId})=>{if(!outcome.changed)return{event:null,search:null};const event=await emitContentEvent(c,definition,EVENT_ACTION[outcome.operation],payloadFor(outcome,{scheduledBy,scheduleId}),{pluginId});await reportContentEventFailures(c,{action:EVENT_ACTION[outcome.operation],contentTypeId:definition.id,event,itemId:idOf(outcome.row)});const delivery=definition.delivery.enabled?await contentDeliveryEffects(c,definition,outcome.delivery,{pluginId}):undefined;if(definition.localization.enabled&&definition.search.enabled){return{...delivery===undefined?{}:{delivery},event,search:null,searchByLocale:model?await syncContentLocalizedSearch(c,model,{advanced:await contentSearchAdvancedValues(c,model,idOf(outcome.row)),changed:outcome.changed||(outcome.movedTranslations??0)>0,changedFields:outcome.changedFields,operation:outcome.operation,pluginId,row:outcome.row}):await warnMissingModel(c,definition)}}return{...delivery===undefined?{}:{delivery},event,search:await syncContentSearch(c,definition,{advanced:model?await contentSearchAdvancedValues(c,model,idOf(outcome.row)):undefined,changed:outcome.changed,changedFields:outcome.changedFields,operation:outcome.operation,pluginId,row:outcome.row})}};const idOf=row=>{const id=row.id;return typeof id==="number"?id:0};const warnMissingModel=async(c,definition)=>{const message=`[content-search] ${definition.id} is localized and searchable, but contentEditorialEffects was called without \`model\`, so no document was written. Pass the content model.`;try{await c.get("log").error(message)}catch{console.error(`[VitNode] ${message}`)}return[]};