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

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

@@ -0,0 +1,77 @@
+import type { PgColumn, PgTableWithColumns, TableConfig } from "drizzle-orm/pg-core";
+import type { Context } from "hono";
+import type { ContentActor, ContentRevisionOperation } from "../revisions";
+import type { ContentSchemas } from "../schemas";
+import type { AnyContentTypeDefinition, ContentChangedPath, ContentCreateInput, ContentInnerFieldsOf, ContentRelationCollectionName, ContentRepeatableFieldName, ContentRepeatableInputRow, ContentRepeatableRow, ContentSelect, ContentUpdateInput, ContentValuesOf } from "../types";
+import type { ContentAdvancedStore } from "./advanced-store";
+import type { ContentDeliveryOutcome } from "./delivery-writes";
+import type { ContentRevisionsModel } from "./revisions-model";
+import type { ContentSchedulesModel } from "./schedules-model";
+import type { ContentDatabase } from "./service";
+export interface ContentEditorialOutcome<TDefinition> {
+    changed: boolean;
+    changedFields: ContentChangedPath<TDefinition>[];
+    delivery?: ContentDeliveryOutcome;
+    movedTranslations?: number;
+    operation: ContentRevisionOperation;
+    previousSlug: null | string;
+    restoredFromRevisionId: null | number;
+    revisionId: null | number;
+    row: ContentSelect<TDefinition>;
+    version: number;
+}
+export interface ContentEditorialOptions {
+    actor: ContentActor;
+    tx?: ContentDatabase;
+}
+export interface ContentEditorialWriteOptions extends ContentEditorialOptions {
+    expectedVersion: number;
+}
+export interface ContentEditorialPublicationOptions extends ContentEditorialOptions {
+    expectedVersion?: number;
+}
+export interface ContentEditorialService<TDefinition> {
+    create: (values: ContentCreateInput<TDefinition>, options: ContentEditorialOptions) => Promise<ContentEditorialOutcome<TDefinition>>;
+    delete: (id: number, options: ContentEditorialWriteOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+    publish: (id: number, options: ContentEditorialPublicationOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+    relations: Record<ContentRelationCollectionName<TDefinition>, ContentEditorialRelationMethods<TDefinition>>;
+    repeatable: {
+        [K in ContentRepeatableFieldName<TDefinition>]: ContentEditorialRepeatableMethods<TDefinition, K>;
+    };
+    restore: (id: number, revisionId: number, options: ContentEditorialWriteOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+    revisions: ContentRevisionsModel;
+    schedules: ContentSchedulesModel | undefined;
+    unpublish: (id: number, options: ContentEditorialPublicationOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+    update: (id: number, values: ContentUpdateInput<TDefinition>, options: ContentEditorialWriteOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+}
+export interface ContentEditorialRelationMethods<TDefinition> {
+    add: (itemId: number, relatedItemId: number, options: ContentEditorialWriteOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+    get: (itemId: number, options?: ContentEditorialOptions) => Promise<number[]>;
+    remove: (itemId: number, relatedItemId: number, options: ContentEditorialWriteOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+    reorder: (itemId: number, relatedItemIds: readonly number[], options: ContentEditorialWriteOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+    set: (itemId: number, relatedItemIds: readonly number[], options: ContentEditorialWriteOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+}
+export interface ContentEditorialRepeatableMethods<TDefinition, TName> {
+    create: (itemId: number, values: ContentValuesOf<ContentInnerFieldsOf<TDefinition, TName>>, options: ContentEditorialWriteOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+    delete: (itemId: number, childId: number, options: ContentEditorialWriteOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+    list: (itemId: number, options?: ContentEditorialOptions) => Promise<ContentRepeatableRow<ContentInnerFieldsOf<TDefinition, TName>>[]>;
+    reorder: (itemId: number, childIds: readonly number[], options: ContentEditorialWriteOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+    set: (itemId: number, rows: readonly ContentRepeatableInputRow<ContentInnerFieldsOf<TDefinition, TName>>[], options: ContentEditorialWriteOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+    update: (itemId: number, childId: number, values: Partial<ContentValuesOf<ContentInnerFieldsOf<TDefinition, TName>>>, options: ContentEditorialWriteOptions) => Promise<ContentEditorialOutcome<TDefinition> | null>;
+}
+export declare const createContentEditorialService: <TDefinition extends AnyContentTypeDefinition>({ advanced, c, cascadeTranslations, columns, definition, pluginId, schemas, table, }: {
+    advanced?: ContentAdvancedStore;
+    c: Context;
+    cascadeTranslations?: ((options: {
+        actor: ContentActor;
+        itemId: number;
+        operation: "publish" | "unpublish";
+        tx: ContentDatabase;
+    }) => Promise<number>) | null;
+    columns: Record<string, PgColumn>;
+    definition: TDefinition;
+    pluginId: string;
+    schemas: ContentSchemas<TDefinition>;
+    table: PgTableWithColumns<TableConfig>;
+}) => ContentEditorialService<TDefinition>;
+//# sourceMappingURL=editorial-service.d.ts.map

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

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

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

@@ -0,0 +1 @@
+import{and,eq,ne,sql}from"drizzle-orm";import{isContentPubliclyVisible}from"../cache.js";import{CONTENT_EDITORIAL_FIELDS,CONTENT_PUBLICATION_FIELDS,CONTENT_SYSTEM_FIELDS}from"../const.js";import{ContentEngineError,ContentRevisionNotRestorable,ContentVersionConflict}from"../errors.js";import{partitionContentFields}from"../localization.js";import{contentColumnsToValues,contentStorageColumns}from"../paths.js";import{buildContentRelationOperations,buildContentRepeatableOperations,contentCollectionKinds}from"./collection-api.js";import{applyContentDeliveryWrite,contentSlugHistoryFor}from"./delivery-writes.js";import{assertContentFileReferences,ContentFileReferenceError,contentSnapshotFileIds}from"./files.js";import{changedPathsToColumns,diffChangedPaths,toInsertColumns}from"./query.js";import{contentRevisionSnapshot,projectRevisionSnapshot}from"./revision-snapshot.js";import{createContentRevisionsModel}from"./revisions-model.js";import{createContentSchedulesModel}from"./schedules-model.js";import{createSlugNormalizer}from"./slugs.js";export const createContentEditorialService=({advanced,c,cascadeTranslations,columns,definition,pluginId,schemas,table})=>{if(!definition.editorial.enabled){throw new ContentEngineError("The editorial service needs `editorial: { enabled: true }` on the content type.",{contentTypeId:definition.id})}const contentTypeId=definition.id;const store=advanced;const{collectionFields,sharedFields}=partitionContentFields(definition.fields);const fields=sharedFields;const storageColumns=contentStorageColumns(fields);const allPaths=[...Object.entries(fields).flatMap(([name,fieldValue])=>fieldValue.kind==="group"?Object.keys(fieldValue.fields).map(leaf=>`${name}.${leaf}`):[name]),...Object.keys(collectionFields)];const primaryCursor=columns.id;const versionColumn=columns.version;const publication=definition.publication.enabled;const slugField=definition.publicApi.enabled?definition.publicApi.slugField:null;const generatedColumnNames=[...CONTENT_SYSTEM_FIELDS,...publication?CONTENT_PUBLICATION_FIELDS:[],...CONTENT_EDITORIAL_FIELDS];const ownColumnNames=[...generatedColumnNames,...Object.keys(storageColumns)];const ownSelection=()=>Object.fromEntries(ownColumnNames.map(name=>[name,columns[name]]));const projectRow=row=>{const projected={};for(const name of generatedColumnNames){if(name in row)projected[name]=row[name]}return{...projected,...contentColumnsToValues(fields,row)}};const revisions=createContentRevisionsModel({c,definition,pluginId});const schedules=definition.editorial.scheduling.enabled?createContentSchedulesModel({c,definition,pluginId}):undefined;const deliveryEnabled=definition.delivery.enabled&&definition.delivery.slugScope==="shared";const slugHistory=contentSlugHistoryFor({c,definition,pluginId});const publiclyVisible=row=>{if(row===null||!publication)return false;return isContentPubliclyVisible({publishedAt:row.publishedAt,status:typeof row.status==="string"?row.status:undefined})};const invert=(operation,row)=>({publishedAt:row.publishedAt,status:operation==="publish"?"draft":"published"});const applyDelivery=async(tx,{after,before,itemId})=>{if(!deliveryEnabled)return undefined;return await applyContentDeliveryWrite({definition,slugHistory,transition:{isPublic:publiclyVisible(after),itemId,languageId:null,locale:null,previousSlug:slugOf(before),slug:slugOf(after),wasPublic:publiclyVisible(before)},tx})};const{withCreateSlugs,withUpdateSlugs}=createSlugNormalizer(contentTypeId,fields);const toRow=row=>projectRow(row);const versionOf=row=>typeof row.version==="number"?row.version:1;const slugOf=row=>{if(!row||slugField===null)return null;const value=row[slugField];return typeof value==="string"?value:null};const readOne=async(id,database)=>{const[row]=await database.select(ownSelection()).from(table).where(eq(primaryCursor,id)).limit(1);return row??null};const transact=async(options,body)=>{if(options.tx)return await body(options.tx);return await c.get("db").transaction(async tx=>await body(tx))};const capture=async(tx,{actor,changedFields,operation,restoredFromRevisionId,row,version})=>{const itemId=typeof row.id==="number"?row.id:0;const collections=operation==="delete"?row.__collections??{}:await store?.load(itemId,tx)??{};const snapshot=contentRevisionSnapshot(definition,{...row,...collections,version});return await revisions.capture(tx,{actor,changedFields,fileIds:contentSnapshotFileIds(definition,snapshot),itemId,operation,restoredFromRevisionId,snapshot,version})};const lockRow=async(tx,id,{force=false}={})=>{if(!force&&!store?.enabled)return true;const[row]=await tx.select({id:primaryCursor}).from(table).where(eq(primaryCursor,id)).limit(1).for("update");return row!==undefined};const guardedWrite=async(tx,id,expectedVersion,values)=>{const[row]=await tx.update(table).set({...values,version:sql`${versionColumn} + 1`}).where(and(eq(primaryCursor,id),eq(versionColumn,expectedVersion))).returning(ownSelection());if(row)return row;const[current]=await tx.select({version:versionColumn}).from(table).where(eq(primaryCursor,id)).limit(1);if(!current)return null;throw new ContentVersionConflict({contentTypeId,currentVersion:versionOf(current),expectedVersion,itemId:id})};const cascade=async(tx,itemId,operation,actor)=>{if(!cascadeTranslations)return 0;if(!definition.publication.enabled)return 0;return await cascadeTranslations({actor,itemId,operation,tx})};const transition=async(id,options,operation,values,guard)=>await transact(options,async tx=>{const conditions=[eq(primaryCursor,id),guard];if(options.expectedVersion!==undefined){conditions.push(eq(versionColumn,options.expectedVersion))}const[row]=await tx.update(table).set({...values,version:sql`${versionColumn} + 1`}).where(and(...conditions)).returning(ownSelection());if(!row){const current=await readOne(id,tx);if(!current)return null;if(options.expectedVersion!==undefined&&versionOf(current)!==options.expectedVersion){throw new ContentVersionConflict({contentTypeId,currentVersion:versionOf(current),expectedVersion:options.expectedVersion,itemId:id})}const moved=await cascade(tx,id,operation,options.actor);return{changed:false,changedFields:[],operation,previousSlug:slugOf(current),restoredFromRevisionId:null,revisionId:null,...moved===0?{}:{movedTranslations:moved},row:toRow(current),version:versionOf(current)}}const moved=await cascade(tx,id,operation,options.actor);const version=versionOf(row);const revisionId=await capture(tx,{actor:options.actor,changedFields:[],operation,row,version});const delivery=await applyDelivery(tx,{after:row,before:{...row,...invert(operation,row)},itemId:id});return{changed:true,changedFields:[],...delivery===undefined?{}:{delivery},...moved===0?{}:{movedTranslations:moved},operation,previousSlug:slugOf(row),restoredFromRevisionId:null,revisionId,row:toRow(row),version}});const assertWriteOptions=(field,options)=>{if(options?.actor&&typeof options.expectedVersion==="number"){return options}throw new ContentEngineError(`An editorial mutation of "${field}" needs \`{ actor, expectedVersion }\`. Use \`model.service(c).${field}\` for a write with no version guard.`,{contentTypeId})};const runCollection=async(itemId,field,compute,options)=>{const write=assertWriteOptions(field,options);return await transact(write,async tx=>{if(!await lockRow(tx,itemId,{force:true}))return null;const current=await store?.load(itemId,tx,[field]);const value=current?.[field];const next=compute(Array.isArray(value)?value:[]);return await editorial.update(itemId,schemas.update.parse({[field]:next}),{...write,tx})})};const collectionApi={read:async(itemId,field,options)=>{const loaded=await store?.load(itemId,options?.tx??c.get("db"),[field]);const value=loaded?.[field];return Array.isArray(value)?value:[]},run:runCollection,write:async(itemId,field,next,options)=>{const write=assertWriteOptions(field,options);return await editorial.update(itemId,{[field]:[...next]},write)}};const{relations,repeatables}=contentCollectionKinds(definition,store?.fields??[]);const mutableRelations={};const mutableRepeatables={};for(const field of relations){mutableRelations[field]=buildContentRelationOperations({api:collectionApi,contentTypeId,field})}for(const field of repeatables){mutableRepeatables[field]=buildContentRepeatableOperations({api:collectionApi,contentTypeId,field})}const editorial={create:async(values,options)=>await transact(options,async tx=>{const parsed=schemas.create.parse(values);await assertContentFileReferences(c,definition,parsed,tx);const[row]=await tx.insert(table).values(toInsertColumns(fields,withCreateSlugs(parsed))).returning(ownSelection());if(store?.enabled&&typeof row.id==="number"){await store.write(tx,row.id,parsed)}const version=versionOf(row);const revisionId=await capture(tx,{actor:options.actor,changedFields:allPaths,operation:"create",row,version});const delivery=await applyDelivery(tx,{after:row,before:null,itemId:typeof row.id==="number"?row.id:0});return{changed:true,changedFields:allPaths,...delivery===undefined?{}:{delivery},operation:"create",previousSlug:null,restoredFromRevisionId:null,revisionId,row:toRow(row),version}}),delete:async(id,options)=>await transact(options,async tx=>{const collections=await store?.load(id,tx)??{};const[row]=await tx.delete(table).where(and(eq(primaryCursor,id),eq(versionColumn,options.expectedVersion))).returning(ownSelection());if(!row){const[current]=await tx.select({version:versionColumn}).from(table).where(eq(primaryCursor,id)).limit(1);if(!current)return null;throw new ContentVersionConflict({contentTypeId,currentVersion:versionOf(current),expectedVersion:options.expectedVersion,itemId:id})}const version=versionOf(row)+1;const revisionId=await capture(tx,{actor:options.actor,changedFields:[],operation:"delete",row:{...row,__collections:collections},version});const delivery=await applyDelivery(tx,{after:null,before:row,itemId:id});return{changed:true,changedFields:[],...delivery===undefined?{}:{delivery},operation:"delete",previousSlug:slugOf(row),restoredFromRevisionId:null,revisionId,row:toRow(row),version}}),publish:async(id,options)=>await transition(id,options,"publish",{publishedAt:sql`coalesce(${columns.publishedAt}, now())`,status:"published"},ne(columns.status,"published")),restore:async(id,revisionId,options)=>await transact(options,async tx=>{const revision=await revisions.findById(id,revisionId,tx);if(!revision)return null;const current=await readOne(id,tx);if(!current)return null;const projected=projectRevisionSnapshot(definition,revision.snapshot);const parsed=schemas.update.safeParse(projected);if(!parsed.success){throw new ContentRevisionNotRestorable({contentTypeId,fields:[...new Set(parsed.error.issues.map(issue=>String(issue.path[0]??"")).filter(name=>name!==""))],revisionId})}const prepared=await store?.prepareRestore(tx,id,parsed.data)??{missingRelations:[],patch:parsed.data};if(prepared.missingRelations.length>0){throw new ContentRevisionNotRestorable({contentTypeId,fields:prepared.missingRelations.map(entry=>`${entry.field} (${entry.ids.join(", ")})`),revisionId})}const patch=withUpdateSlugs(prepared.patch);try{await assertContentFileReferences(c,definition,patch,tx)}catch(error){if(!(error instanceof ContentFileReferenceError))throw error;throw new ContentRevisionNotRestorable({contentTypeId,fields:[error.field],revisionId})}const changedPaths=diffChangedPaths(fields,current,patch);const changedCollections=await store?.diff(tx,id,patch)??[];const changedFields=[...changedPaths,...changedCollections];if(changedFields.length===0){return{changed:false,changedFields,operation:"restore",previousSlug:slugOf(current),restoredFromRevisionId:null,revisionId:null,row:toRow(current),version:versionOf(current)}}const row=await guardedWrite(tx,id,options.expectedVersion,changedPaths.length>0?changedPathsToColumns(fields,patch,changedPaths):{});if(!row)return null;if(changedCollections.length>0)await store?.write(tx,id,patch);const version=versionOf(row);const newRevisionId=await capture(tx,{actor:options.actor,changedFields,operation:"restore",restoredFromRevisionId:revisionId,row,version});const delivery=await applyDelivery(tx,{after:row,before:current,itemId:id});return{changed:true,changedFields,...delivery===undefined?{}:{delivery},operation:"restore",previousSlug:slugOf(current),restoredFromRevisionId:revisionId,revisionId:newRevisionId,row:toRow(row),version}}),relations:mutableRelations,repeatable:mutableRepeatables,revisions,schedules,unpublish:async(id,options)=>await transition(id,options,"unpublish",{status:"draft"},eq(columns.status,"published")),update:async(id,values,options)=>await transact(options,async tx=>{const patch=withUpdateSlugs(schemas.update.parse(values));if(!await lockRow(tx,id))return null;const current=await readOne(id,tx);if(!current)return null;const changedPaths=diffChangedPaths(fields,current,patch);const changedCollections=await store?.diff(tx,id,patch)??[];const changedFields=[...changedPaths,...changedCollections];if(changedFields.length===0){return{changed:false,changedFields,operation:"update",previousSlug:slugOf(current),restoredFromRevisionId:null,revisionId:null,row:toRow(current),version:versionOf(current)}}await assertContentFileReferences(c,definition,patch,tx);const row=await guardedWrite(tx,id,options.expectedVersion,changedPaths.length>0?changedPathsToColumns(fields,patch,changedPaths):{});if(!row)return null;if(changedCollections.length>0)await store?.write(tx,id,patch);const version=versionOf(row);const revisionId=await capture(tx,{actor:options.actor,changedFields,operation:"update",row,version});const delivery=await applyDelivery(tx,{after:row,before:current,itemId:id});return{changed:true,changedFields,...delivery===undefined?{}:{delivery},operation:"update",previousSlug:slugOf(current),restoredFromRevisionId:null,revisionId,row:toRow(row),version}})};return editorial};

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

@@ -0,0 +1,11 @@
+import type { Context } from "hono";
+import type { EventEmitResult } from "../../api/models/events";
+export declare const CONTENT_EFFECTS_LOG_PREFIX = "[content-effects]";
+export declare const reportContentEventFailures: (c: Context, { action, contentTypeId, event, itemId, locale, }: {
+    action: string;
+    contentTypeId: string;
+    event: EventEmitResult | null;
+    itemId: number;
+    locale?: string;
+}) => Promise<void>;
+//# sourceMappingURL=effects-log.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"effects-log.d.ts","sourceRoot":"","sources":["../../../../src/content/server/effects-log.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAW/D,eAAO,MAAM,0BAA0B,sBAAsB,CAAC;AA0B9D,eAAO,MAAM,0BAA0B,GACrC,GAAG,OAAO,EACV,mDAMG;IACD,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IAEf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,KACA,OAAO,CAAC,IAAI,CAyBd,CAAC"}

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

@@ -0,0 +1 @@
+export const CONTENT_EFFECTS_LOG_PREFIX="[content-effects]";export const reportContentEventFailures=async(c,{action,contentTypeId,event,itemId,locale})=>{if(!event||event.failures.length===0)return;const message=`${CONTENT_EFFECTS_LOG_PREFIX} ${JSON.stringify({action,contentTypeId,delivered:event.delivered,eventId:event.eventId,failures:event.failures.map(failure=>({error:failure.error,listener:`${failure.pluginId}:${failure.module}:${failure.listener}`})),itemId,...locale===undefined?{}:{locale}})}`;try{await c.get("log").error(message)}catch{console.error(`[VitNode] ${message}`)}};

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

@@ -0,0 +1,10 @@
+import type { Context } from "hono";
+import type { EventEmitResult } from "../../api/models/events";
+import type { ContentCreatedPayload, ContentDeletedPayload, ContentEventAction, ContentPublishedPayload, ContentTranslationCreatedPayload, ContentTranslationDeletedPayload, ContentTranslationPublishedPayload, ContentTranslationRestoredPayload, ContentTranslationUnpublishedPayload, ContentTranslationUpdatedPayload, ContentUnpublishedPayload, ContentUpdatedPayload } from "../events";
+import type { AnyContentTypeDefinition } from "../types";
+type ContentPayload = ContentCreatedPayload | ContentDeletedPayload | ContentPublishedPayload | ContentTranslationCreatedPayload | ContentTranslationDeletedPayload | ContentTranslationPublishedPayload | ContentTranslationRestoredPayload<AnyContentTypeDefinition> | ContentTranslationUnpublishedPayload | ContentTranslationUpdatedPayload<AnyContentTypeDefinition> | ContentUnpublishedPayload | ContentUpdatedPayload<AnyContentTypeDefinition>;
+export declare const emitContentEvent: (c: Context, definition: AnyContentTypeDefinition, action: ContentEventAction, payload: ContentPayload, options?: {
+    pluginId?: string;
+}) => Promise<EventEmitResult>;
+export {};
+//# sourceMappingURL=emit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../../../src/content/server/emit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,KAAK,EAEV,eAAe,EAEhB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,uBAAuB,EACvB,gCAAgC,EAChC,gCAAgC,EAChC,kCAAkC,EAClC,iCAAiC,EACjC,oCAAoC,EACpC,gCAAgC,EAChC,yBAAyB,EACzB,qBAAqB,EACtB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAIzD,KAAK,cAAc,GACf,qBAAqB,GACrB,qBAAqB,GACrB,uBAAuB,GACvB,gCAAgC,GAChC,gCAAgC,GAChC,kCAAkC,GAClC,iCAAiC,CAAC,wBAAwB,CAAC,GAC3D,oCAAoC,GACpC,gCAAgC,CAAC,wBAAwB,CAAC,GAC1D,yBAAyB,GACzB,qBAAqB,CAAC,wBAAwB,CAAC,CAAC;AAwCpD,eAAO,MAAM,gBAAgB,GAC3B,GAAG,OAAO,EACV,YAAY,wBAAwB,EACpC,QAAQ,kBAAkB,EAC1B,SAAS,cAAc,EACvB,UAAU;IAOR,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,KACA,OAAO,CAAC,eAAe,CAKzB,CAAC"}

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

@@ -0,0 +1 @@
+import{contentEventName}from"../events.js";export const emitContentEvent=async(c,definition,action,payload,options)=>{const name=contentEventName(definition.id,action);const events=c.get("events");return await events.emit(name,payload,{pluginId:options?.pluginId})};

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

@@ -0,0 +1,31 @@
+import type { Context } from "hono";
+import type { StorageFileUploadResult } from "../../api/models/storage";
+import type { ContentFileConstraints, ContentFileDescriptor, ContentFileFieldValue, ContentFileRejection } from "../files";
+import type { AnyContentTypeDefinition, ContentFileField } from "../types";
+import type { ContentDatabase } from "./service";
+import { ContentInputError } from "../errors";
+export declare const contentFileFields: (definition: AnyContentTypeDefinition) => Record<string, ContentFileField>;
+export declare const contentFileCollectionFields: (definition: AnyContentTypeDefinition) => Record<string, ContentFileField>;
+export declare const resolveContentFileDescriptors: (c: Context, ids: readonly number[], tx?: ContentDatabase) => Promise<Map<number, ContentFileDescriptor>>;
+export declare const withContentRowFiles: <TRow extends object>(c: Context, definition: AnyContentTypeDefinition, rows: readonly TRow[]) => Promise<(TRow & {
+    files: Record<string, ContentFileFieldValue>;
+})[]>;
+export declare const resolveContentPublicRowFiles: (c: Context, definition: AnyContentTypeDefinition, rows: Record<string, unknown>[]) => Promise<Record<string, unknown>[]>;
+export declare const assertContentFileReferences: (c: Context, definition: AnyContentTypeDefinition, values: Record<string, unknown>, tx?: ContentDatabase) => Promise<void>;
+export declare class ContentFileReferenceError extends ContentInputError {
+    constructor({ code, contentTypeId, field, message, }: {
+        code: ContentFileRejection["code"];
+        contentTypeId: string;
+        field: string;
+        message: string;
+    });
+    readonly code: ContentFileRejection["code"];
+    readonly detail: string;
+    readonly field: string;
+}
+export declare const contentSnapshotFileIds: (definition: AnyContentTypeDefinition, snapshot: {
+    fields?: Record<string, unknown>;
+}) => number[];
+export declare const contentFileDescriptorFromUpload: (result: StorageFileUploadResult) => ContentFileDescriptor;
+export declare const contentFileFieldConstraints: (fieldValue: ContentFileField) => ContentFileConstraints;
+//# sourceMappingURL=files.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../../../src/content/server/files.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAIpC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,KAAK,EACV,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAKjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAkB9C,eAAO,MAAM,iBAAiB,GAC5B,YAAY,wBAAwB,KACnC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAcjC,CAAC;AAUF,eAAO,MAAM,2BAA2B,GACtC,YAAY,wBAAwB,KACnC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAK/B,CAAC;AA4DJ,eAAO,MAAM,6BAA6B,GACxC,GAAG,OAAO,EACV,KAAK,SAAS,MAAM,EAAE,EACtB,KAAK,eAAe,KACnB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAgB5C,CAAC;AAmEF,eAAO,MAAM,mBAAmB,GAAU,IAAI,SAAS,MAAM,EAC3D,GAAG,OAAO,EACV,YAAY,wBAAwB,EACpC,MAAM,SAAS,IAAI,EAAE,KACpB,OAAO,CAAC,CAAC,IAAI,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAA;CAAE,CAAC,EAAE,CAkCrE,CAAC;AAoBF,eAAO,MAAM,4BAA4B,GACvC,GAAG,OAAO,EACV,YAAY,wBAAwB,EACpC,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CA4BnC,CAAC;AAyBF,eAAO,MAAM,2BAA2B,GACtC,GAAG,OAAO,EACV,YAAY,wBAAwB,EACpC,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,KAAK,eAAe,KACnB,OAAO,CAAC,IAAI,CA8Cd,CAAC;AAUF,qBAAa,yBAA0B,SAAQ,iBAAiB;gBAClD,EACV,IAAI,EACJ,aAAa,EACb,KAAK,EACL,OAAO,GACR,EAAE;QACD,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAC,CAAC;QACnC,aAAa,EAAE,MAAM,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;KACjB;IASD,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAC,CAAC;IAU5C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAgBD,eAAO,MAAM,sBAAsB,GACjC,YAAY,wBAAwB,EACpC,UAAU;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,KAC7C,MAAM,EAKR,CAAC;AAUF,eAAO,MAAM,+BAA+B,GAC1C,QAAQ,uBAAuB,KAC9B,qBASD,CAAC;AAGH,eAAO,MAAM,2BAA2B,GACtC,YAAY,gBAAgB,KAC3B,sBAA4D,CAAC"}

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

@@ -0,0 +1 @@
+import{inArray}from"drizzle-orm";import{core_files}from"../../database/files.js";import{parseImageDimensions}from"../../lib/api/upload.js";import{CONTENT_FILE_CODES}from"../const.js";import{ContentInputError}from"../errors.js";import{contentFileConstraints,validateContentFile}from"../files.js";import{partitionContentFields}from"../localization.js";export const contentFileFields=definition=>{const{collectionFields,sharedFields}=partitionContentFields(definition.fields);const files={};for(const[name,fieldValue]of[...Object.entries(sharedFields),...Object.entries(collectionFields)]){if(fieldValue.kind==="file")files[name]=fieldValue}return files};export const contentFileCollectionFields=definition=>Object.fromEntries(Object.entries(contentFileFields(definition)).filter(([,fieldValue])=>fieldValue.multiple));const fileSelection={id:core_files.id,key:core_files.key,metadata:core_files.metadata,mimeType:core_files.mimeType,name:core_files.name,size:core_files.size};const toDescriptor=(row,url)=>{const dimensions=parseImageDimensions(row.metadata);return{id:row.id,mimeType:row.mimeType,name:row.name,size:row.size,url:url(row.key),...dimensions?{height:dimensions.height,width:dimensions.width}:{}}};export const resolveContentFileDescriptors=async(c,ids,tx)=>{const unique=[...new Set(ids.filter(id=>Number.isInteger(id)&&id>0))];if(unique.length===0)return new Map;const rows=await (tx??c.get("db")).select(fileSelection).from(core_files).where(inArray(core_files.id,unique));const hasAdapter=!!c.get("core").storage?.adapter;const storage=c.get("storage");const url=key=>hasAdapter?storage.getUrl(key):"";return new Map(rows.map(row=>[row.id,toDescriptor(row,url)]))};const asFileId=value=>typeof value==="number"&&Number.isInteger(value)&&value>0?value:null;const fileIdsOfValue=value=>{if(Array.isArray(value)){return value.map(asFileId).filter(id=>id!==null)}const id=asFileId(value);return id===null?[]:[id]};const fileIdsOf=(names,values)=>names.flatMap(name=>fileIdsOfValue(values[name]));const descriptorsOf=(byId,value)=>fileIdsOfValue(value).map(id=>byId.get(id)).filter(file=>file!==undefined);export const withContentRowFiles=async(c,definition,rows)=>{const fields=contentFileFields(definition);const names=Object.keys(fields);if(names.length===0){return rows.map(row=>({...row,files:{}}))}const byId=await resolveContentFileDescriptors(c,rows.flatMap(row=>fileIdsOf(names,row)));return rows.map(row=>{const values=row;return{...row,files:Object.fromEntries(names.flatMap(name=>{if(fields[name].multiple){const ids=values[name];if(!Array.isArray(ids))return[];return[[name,descriptorsOf(byId,ids)]]}const id=asFileId(values[name]);return[[name,id===null?null:byId.get(id)??null]]}))}})};export const resolveContentPublicRowFiles=async(c,definition,rows)=>{if(!definition.publicApi.enabled||rows.length===0)return rows;const files=contentFileFields(definition);const names=definition.publicApi.fields.filter(name=>files[name]!==undefined);if(names.length===0)return rows;const byId=await resolveContentFileDescriptors(c,rows.flatMap(row=>fileIdsOf(names,row)));return rows.map(row=>({...row,...Object.fromEntries(names.map(name=>{if(files[name].multiple){return[name,descriptorsOf(byId,row[name])]}const id=asFileId(row[name]);return[name,id===null?null:byId.get(id)??null]}))}))};export const assertContentFileReferences=async(c,definition,values,tx)=>{const files=contentFileFields(definition);const named=Object.keys(files).flatMap(name=>(files[name].multiple?Array.isArray(values[name])?fileIdsOfValue(values[name]):[]:fileIdsOfValue(asFileId(values[name]))).map(id=>({id,name})));if(named.length===0)return;const byId=await resolveContentFileDescriptors(c,named.map(entry=>entry.id),tx);for(const{id,name}of named){const descriptor=byId.get(id);if(!descriptor){throw new ContentFileReferenceError({code:CONTENT_FILE_CODES.missing,contentTypeId:definition.id,field:name,message:`File ${id} does not exist, so "${name}" cannot point at it.`})}const rejection=validateContentFile(contentFileConstraints(files[name]),descriptor);if(rejection){throw new ContentFileReferenceError({code:rejection.code,contentTypeId:definition.id,field:name,message:`File ${id} cannot be used for "${name}": ${rejection.message}`})}}};export class ContentFileReferenceError extends ContentInputError{constructor({code,contentTypeId,field,message}){super(message,{contentTypeId});this.name="ContentFileReferenceError";this.code=code;this.detail=message;this.field=field}code;detail;field}export const contentSnapshotFileIds=(definition,snapshot)=>{const names=Object.keys(contentFileFields(definition));if(names.length===0)return[];return[...new Set(fileIdsOf(names,snapshot.fields??{}))]};export const contentFileDescriptorFromUpload=result=>({id:result.id,mimeType:result.mimeType,name:result.name,size:result.size,url:result.url,...result.dimensions?{height:result.dimensions.height,width:result.dimensions.width}:{}});export const contentFileFieldConstraints=fieldValue=>contentFileConstraints(fieldValue);

package/dist/src/content/server/http-errors.d.ts

@@ -0,0 +1,28 @@
+import { HTTPException } from "hono/http-exception";
+import type { ContentConflict, ContentDeliveryConflict, ContentUnprocessable } from "../conflicts";
+import type { ContentScheduleCode } from "../schedules";
+export declare const contentConflict: (body: ContentConflict) => HTTPException;
+export declare const contentDeliveryConflict: (body: ContentDeliveryConflict) => HTTPException;
+export declare const contentUnprocessable: (body: ContentUnprocessable) => HTTPException;
+export declare const contentFileRejected: (body: {
+    code: string;
+    field: string;
+    message: string;
+}) => HTTPException;
+export declare const contentScheduleRejected: (body: {
+    code: ContentScheduleCode;
+    contentTypeId: string;
+}) => HTTPException;
+export declare const rethrowAsHttpError: (error: unknown, { action, contentTypeId, itemId, structured, }: {
+    action: "create" | "delete" | "update";
+    contentTypeId?: string;
+    itemId?: number;
+    structured?: boolean;
+}) => never;
+export interface ContentHttpErrorOptions {
+    contentTypeId?: string;
+    itemId?: number;
+    structured?: boolean;
+}
+export declare const withHttpErrors: <TResult>(action: "create" | "delete" | "update", run: () => Promise<TResult>, options?: ContentHttpErrorOptions) => Promise<TResult>;
+//# sourceMappingURL=http-errors.d.ts.map

package/dist/src/content/server/http-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-errors.d.ts","sourceRoot":"","sources":["../../../../src/content/server/http-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,KAAK,EACV,eAAe,EACf,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAsCxD,eAAO,MAAM,eAAe,GAAI,MAAM,eAAe,KAAG,aAClC,CAAC;AAWvB,eAAO,MAAM,uBAAuB,GAClC,MAAM,uBAAuB,KAC5B,aAAqC,CAAC;AAGzC,eAAO,MAAM,oBAAoB,GAC/B,MAAM,oBAAoB,KACzB,aAAqC,CAAC;AAWzC,eAAO,MAAM,mBAAmB,GAAI,MAAM;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,KAAG,aAAqC,CAAC;AAS1C,eAAO,MAAM,uBAAuB,GAAI,MAAM;IAC5C,IAAI,EAAE,mBAAmB,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;CACvB,KAAG,aAAqC,CAAC;AAa1C,eAAO,MAAM,kBAAkB,GAC7B,OAAO,OAAO,EACd,gDAKG;IACD,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACvC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,KACA,KA+FF,CAAC;AAEF,MAAM,WAAW,uBAAuB;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAGD,eAAO,MAAM,cAAc,GAAU,OAAO,EAC1C,QAAQ,QAAQ,GAAG,QAAQ,GAAG,QAAQ,EACtC,KAAK,MAAM,OAAO,CAAC,OAAO,CAAC,EAC3B,UAAS,uBAA4B,KACpC,OAAO,CAAC,OAAO,CAQjB,CAAC"}

package/dist/src/content/server/http-errors.js

@@ -0,0 +1 @@
+import{HTTPException}from"hono/http-exception";import{ZodError}from"zod";import{PG_ERROR_CODES,pgErrorCode}from"../../lib/api/pg-error.js";import{CONTENT_CONFLICT_CODES,CONTENT_DELIVERY_CODES,CONTENT_UNPROCESSABLE_CODES}from"../const.js";import{ContentDeliverySlugReserved,ContentInputError,ContentRevisionNotRestorable,ContentScheduleError,ContentVersionConflict}from"../errors.js";import{ContentFileReferenceError}from"./files.js";const{foreignKeyViolation:FOREIGN_KEY_VIOLATION,notNullViolation:NOT_NULL_VIOLATION,restrictViolation:RESTRICT_VIOLATION,uniqueViolation:UNIQUE_VIOLATION}=PG_ERROR_CODES;const jsonError=(status,body)=>new HTTPException(status,{res:Response.json(body,{status})});export const contentConflict=body=>jsonError(409,body);export const contentDeliveryConflict=body=>jsonError(409,body);export const contentUnprocessable=body=>jsonError(422,body);export const contentFileRejected=body=>jsonError(400,body);export const contentScheduleRejected=body=>jsonError(400,body);export const rethrowAsHttpError=(error,{action,contentTypeId,itemId,structured=false})=>{if(error instanceof ContentVersionConflict){throw contentConflict({code:CONTENT_CONFLICT_CODES.version,contentTypeId:error.contentTypeId??contentTypeId??"",currentVersion:error.currentVersion,expectedVersion:error.expectedVersion,itemId:error.itemId})}if(error instanceof ContentDeliverySlugReserved){throw contentDeliveryConflict({code:CONTENT_DELIVERY_CODES.slugReserved,contentTypeId:error.contentTypeId??contentTypeId??"",locale:error.locale,slug:error.slug})}if(error instanceof ContentScheduleError){throw contentScheduleRejected({code:error.code,contentTypeId:error.contentTypeId??contentTypeId??""})}if(error instanceof ContentRevisionNotRestorable){throw contentUnprocessable({code:CONTENT_UNPROCESSABLE_CODES.notRestorable,contentTypeId:error.contentTypeId??contentTypeId??"",fields:error.fields,revisionId:error.revisionId})}if(error instanceof ZodError){throw new HTTPException(400,{message:"Invalid input data."})}if(error instanceof ContentFileReferenceError){throw contentFileRejected({code:error.code,field:error.field,message:error.detail})}if(error instanceof ContentInputError){throw new HTTPException(400,{message:error.message})}switch(pgErrorCode(error)){case FOREIGN_KEY_VIOLATION:throw new HTTPException(action==="delete"?409:400,{message:action==="delete"?"This record is still referenced by other content.":"A related record does not exist."});case RESTRICT_VIOLATION:throw new HTTPException(409,{message:"This record is still referenced by other content."});case NOT_NULL_VIOLATION:throw new HTTPException(400,{message:"A required field is missing."});case UNIQUE_VIOLATION:throw structured?contentConflict({code:CONTENT_CONFLICT_CODES.unique,contentTypeId:contentTypeId??"",itemId:itemId??null}):new HTTPException(409,{message:"A record with these values already exists."});default:throw error}};export const withHttpErrors=async(action,run,options={})=>{try{return await run()}catch(error){if(error instanceof HTTPException)throw error;return rethrowAsHttpError(error,{action,...options})}};

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

@@ -0,0 +1,79 @@
+export { CONTENT_SYSTEM_ACTOR, resolveContentActor } from "./actor";
+export { buildContentColumn, buildEditorialColumns, buildPublicationColumns, buildSystemColumns, buildTranslationPublicationColumns, buildTranslationSystemColumns, } from "./column-builders";
+export type { ColumnReferenceThunk } from "./column-builders";
+export { readDeliveryAlternates, readDeliveryAlternatesMany, } from "./delivery-alternates";
+export { contentDeliveryEffects, contentDeliveryInvalidation, } from "./delivery-effects";
+export type { ContentDeliveryEffectsResult } from "./delivery-effects";
+export { buildContentDeliveryRoutes } from "./delivery-routes";
+export { createContentDeliveryService } from "./delivery-service";
+export type { ContentDeliveryMetadata, ContentDeliveryReadOptions, ContentDeliveryResolution, ContentDeliveryService, ContentDeliverySitemapArgs, } from "./delivery-service";
+export { readContentDeliverySitemapPage } from "./delivery-sitemap";
+export type { ContentDeliverySitemapPage } from "./delivery-sitemap";
+export { applyContentDeliveryWrite, contentSlugHistoryFor, } from "./delivery-writes";
+export type { ContentDeliveryOutcome, ContentDeliveryTransition, } from "./delivery-writes";
+export { contentEngineDiagnostics, contentScheduleHealth, contentSearchDrift, } from "./diagnostics";
+export type { ContentEngineDiagnostics, ContentScheduleHealth, ContentSearchDrift, ContentSearchDriftLocale, ContentTypeDiagnostic, } from "./diagnostics";
+export { contentEditorialEffects } from "./editorial-effects";
+export type { ContentEditorialEffectsOptions, ContentEditorialEffectsResult, } from "./editorial-effects";
+export { createContentEditorialService } from "./editorial-service";
+export type { ContentEditorialOptions, ContentEditorialOutcome, ContentEditorialPublicationOptions, ContentEditorialService, ContentEditorialWriteOptions, } from "./editorial-service";
+export { CONTENT_EFFECTS_LOG_PREFIX, reportContentEventFailures, } from "./effects-log";
+export { emitContentEvent } from "./emit";
+export { assertContentFileReferences, contentFileCollectionFields, contentFileDescriptorFromUpload, contentFileFields, ContentFileReferenceError, contentSnapshotFileIds, resolveContentFileDescriptors, resolveContentPublicRowFiles, withContentRowFiles, } from "./files";
+export { contentConflict, contentUnprocessable, rethrowAsHttpError, withHttpErrors, } from "./http-errors";
+export type { ContentHttpErrorOptions } from "./http-errors";
+export { assertContentLocalizationLanguages, ensureContentLocalizationLanguages, findContentLanguage, findContentLocalizationProblems, listContentLanguages, resetContentLocalizationCheck, resolveContentLanguage, resolveDefaultContentLanguage, } from "./language-resolver";
+export type { ContentLanguage, ContentLocalizationProblem, } from "./language-resolver";
+export { createContentLocalizedPublicService } from "./localized-public-service";
+export { createContentLocalizedService } from "./localized-service";
+export type { ContentLocalizedCreateInput, ContentLocalizedCreateOptions, ContentLocalizedCreateResult, ContentLocalizedService, } from "./localized-service";
+export { createContentModel, findContentModel } from "./model";
+export type { AnyContentModel, ContentModel, RegisteredContentModel, } from "./model";
+export { buildContentAdminModule } from "./module";
+export { assertContentPreviewIsServable, contentPreviewSecret, contentPreviewUrl, } from "./preview-link";
+export { CONTENT_PREVIEW_SECRET_NAME, ensureContentPreviewSecret, resetContentPreviewSecret, } from "./preview-secret";
+export { resolveContentPreviewTarget, resolveContentTranslationPreviewSlug, } from "./preview-target";
+export type { ContentPreviewTarget } from "./preview-target";
+export { createContentPreviewToken, verifyContentPreviewToken, zodContentPreviewTokenPayload, } from "./preview-token";
+export type { ContentPreviewToken, ContentPreviewTokenPayload, } from "./preview-token";
+export { contentPublicLocaleStates } from "./public-locales";
+export { buildContentPublicModule } from "./public-module";
+export { buildContentPublicRoutes } from "./public-routes";
+export { contentPublicSelection, createContentPublicProjector, createContentPublicService, } from "./public-service";
+export type { ContentPublicFindManyArgs, ContentPublicReadOptions, ContentPublicService, } from "./public-service";
+export { contentPublicCondition, contentTranslationPublicationColumns, publicationColumns, publicationMethods, publishedCondition, } from "./publication";
+export type { PublicationColumns } from "./publication";
+export { buildFilterCondition, buildOrderColumn, buildSearchCondition, diffChangedFields, escapeLikePattern, toColumnValues, } from "./query";
+export { LABEL_PREFIX, resolveReferenceTargets, toLabel } from "./references";
+export type { ReferenceTarget } from "./references";
+export { contentRevisionSnapshot, contentSnapshotRow, contentTranslationRevisionSnapshot, contentTranslationSnapshotRow, projectRevisionSnapshot, projectTranslationRevisionSnapshot, } from "./revision-snapshot";
+export { CONTENT_REVISIONS_DEFAULT_PAGE_SIZE, CONTENT_REVISIONS_MAX_PAGE_SIZE, createContentRevisionsModel, } from "./revisions-model";
+export type { ContentRevisionCaptureInput, ContentRevisionPage, ContentRevisionsModel, } from "./revisions-model";
+export { buildContentRoutes } from "./routes";
+export { contentScheduleEffectsPayloadSchema, runContentScheduleEffects, } from "./schedule-effects";
+export type { ContentScheduleEffectsOutcome, ContentScheduleEffectsPayload, } from "./schedule-effects";
+export { claimContentSchedule, createContentSchedulesModel, pruneContentSchedules, recordContentScheduleEffectsError, settleContentSchedule, } from "./schedules-model";
+export type { ClaimedContentSchedule, ContentSchedulesModel, } from "./schedules-model";
+export { contentSearchDocument, contentTranslationSearchDocument, } from "./search-document";
+export { createContentLocalizedSearchIndexer, createContentSearchIndexer, } from "./search-indexer";
+export type { ContentSearchIndexer } from "./search-indexer";
+export { syncContentLocalizedSearch, syncContentSearch } from "./search-sync";
+export type { ContentLocalizedSearchSyncInput, ContentSearchOperation, ContentSearchSyncInput, ContentSearchSyncOutcome, } from "./search-sync";
+export { createContentService } from "./service";
+export type { ContentDatabase, ContentFindManyArgs, ContentLabels, ContentListRow, ContentPageInfo, ContentPublicationMethods, ContentPublicationResult, ContentService, ContentServiceBase, ContentServiceOptions, ContentUpdateResult, } from "./service";
+export { contentSlugHistoryCurrentPaths, contentSlugHistoryPath, createContentSlugHistoryModel, } from "./slug-history-model";
+export type { ContentSlugHistoryEntry, ContentSlugHistoryModel, ContentSlugHistoryTarget, } from "./slug-history-model";
+export { createSlugNormalizer } from "./slugs";
+export type { ContentSlugNormalizer } from "./slugs";
+export { assertContentReferences, contentTableColumns, createContentTable, } from "./table";
+export { createContentTranslationEditorialService } from "./translation-editorial-service";
+export type { ContentRevisionDetailForLocale, ContentTranslationEditorialOptions, ContentTranslationEditorialOutcome, ContentTranslationEditorialService, ContentTranslationEditorialTransitionOptions, ContentTranslationEditorialWriteOptions, } from "./translation-editorial-service";
+export { contentTranslationEffects } from "./translation-effects";
+export type { ContentTranslationEffectsOptions, ContentTranslationEffectsResult, } from "./translation-effects";
+export { contentTranslationConflict, withTranslationHttpErrors, } from "./translation-http-errors";
+export { createContentTranslationModel } from "./translation-model";
+export type { ContentTranslationModel, ContentTranslationOptions, ContentTranslationTransitionOptions, ContentTranslationTransitionResult, ContentTranslationUpdateResult, ContentTranslationWriteOptions, } from "./translation-model";
+export { buildContentTranslationRoutes } from "./translation-routes";
+export { contentTranslationTableColumns, createContentTranslationTable, } from "./translation-table";
+export type { ContentColumnBuilder, ContentColumnBuilders, ContentColumnName, ContentEditorialColumnBuilders, ContentPublicationColumnBuilders, ContentReferences, ContentSystemColumnBuilders, ContentTable, ContentTableFor, ContentTranslationColumnBuilders, ContentTranslationColumnName, ContentTranslationSystemColumnBuilders, ContentTranslationTable, ContentTranslationTableFor, } from "./types";
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1 @@
+export{CONTENT_SYSTEM_ACTOR,resolveContentActor}from"./actor.js";export{buildContentColumn,buildEditorialColumns,buildPublicationColumns,buildSystemColumns,buildTranslationPublicationColumns,buildTranslationSystemColumns}from"./column-builders.js";export{readDeliveryAlternates,readDeliveryAlternatesMany}from"./delivery-alternates.js";export{contentDeliveryEffects,contentDeliveryInvalidation}from"./delivery-effects.js";export{buildContentDeliveryRoutes}from"./delivery-routes.js";export{createContentDeliveryService}from"./delivery-service.js";export{readContentDeliverySitemapPage}from"./delivery-sitemap.js";export{applyContentDeliveryWrite,contentSlugHistoryFor}from"./delivery-writes.js";export{contentEngineDiagnostics,contentScheduleHealth,contentSearchDrift}from"./diagnostics.js";export{contentEditorialEffects}from"./editorial-effects.js";export{createContentEditorialService}from"./editorial-service.js";export{CONTENT_EFFECTS_LOG_PREFIX,reportContentEventFailures}from"./effects-log.js";export{emitContentEvent}from"./emit.js";export{assertContentFileReferences,contentFileCollectionFields,contentFileDescriptorFromUpload,contentFileFields,ContentFileReferenceError,contentSnapshotFileIds,resolveContentFileDescriptors,resolveContentPublicRowFiles,withContentRowFiles}from"./files.js";export{contentConflict,contentUnprocessable,rethrowAsHttpError,withHttpErrors}from"./http-errors.js";export{assertContentLocalizationLanguages,ensureContentLocalizationLanguages,findContentLanguage,findContentLocalizationProblems,listContentLanguages,resetContentLocalizationCheck,resolveContentLanguage,resolveDefaultContentLanguage}from"./language-resolver.js";export{createContentLocalizedPublicService}from"./localized-public-service.js";export{createContentLocalizedService}from"./localized-service.js";export{createContentModel,findContentModel}from"./model.js";export{buildContentAdminModule}from"./module.js";export{assertContentPreviewIsServable,contentPreviewSecret,contentPreviewUrl}from"./preview-link.js";export{CONTENT_PREVIEW_SECRET_NAME,ensureContentPreviewSecret,resetContentPreviewSecret}from"./preview-secret.js";export{resolveContentPreviewTarget,resolveContentTranslationPreviewSlug}from"./preview-target.js";export{createContentPreviewToken,verifyContentPreviewToken,zodContentPreviewTokenPayload}from"./preview-token.js";export{contentPublicLocaleStates}from"./public-locales.js";export{buildContentPublicModule}from"./public-module.js";export{buildContentPublicRoutes}from"./public-routes.js";export{contentPublicSelection,createContentPublicProjector,createContentPublicService}from"./public-service.js";export{contentPublicCondition,contentTranslationPublicationColumns,publicationColumns,publicationMethods,publishedCondition}from"./publication.js";export{buildFilterCondition,buildOrderColumn,buildSearchCondition,diffChangedFields,escapeLikePattern,toColumnValues}from"./query.js";export{LABEL_PREFIX,resolveReferenceTargets,toLabel}from"./references.js";export{contentRevisionSnapshot,contentSnapshotRow,contentTranslationRevisionSnapshot,contentTranslationSnapshotRow,projectRevisionSnapshot,projectTranslationRevisionSnapshot}from"./revision-snapshot.js";export{CONTENT_REVISIONS_DEFAULT_PAGE_SIZE,CONTENT_REVISIONS_MAX_PAGE_SIZE,createContentRevisionsModel}from"./revisions-model.js";export{buildContentRoutes}from"./routes.js";export{contentScheduleEffectsPayloadSchema,runContentScheduleEffects}from"./schedule-effects.js";export{claimContentSchedule,createContentSchedulesModel,pruneContentSchedules,recordContentScheduleEffectsError,settleContentSchedule}from"./schedules-model.js";export{contentSearchDocument,contentTranslationSearchDocument}from"./search-document.js";export{createContentLocalizedSearchIndexer,createContentSearchIndexer}from"./search-indexer.js";export{syncContentLocalizedSearch,syncContentSearch}from"./search-sync.js";export{createContentService}from"./service.js";export{contentSlugHistoryCurrentPaths,contentSlugHistoryPath,createContentSlugHistoryModel}from"./slug-history-model.js";export{createSlugNormalizer}from"./slugs.js";export{assertContentReferences,contentTableColumns,createContentTable}from"./table.js";export{createContentTranslationEditorialService}from"./translation-editorial-service.js";export{contentTranslationEffects}from"./translation-effects.js";export{contentTranslationConflict,withTranslationHttpErrors}from"./translation-http-errors.js";export{createContentTranslationModel}from"./translation-model.js";export{buildContentTranslationRoutes}from"./translation-routes.js";export{contentTranslationTableColumns,createContentTranslationTable}from"./translation-table.js";

package/dist/src/content/server/language-resolver.d.ts

@@ -0,0 +1,30 @@
+import type { Context } from "hono";
+import type { RegisteredContentType } from "../registry";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentDatabase } from "./service";
+export interface ContentLanguage {
+    id: number;
+    isDefault: boolean;
+    isEnabled: boolean;
+    locale: string;
+}
+export declare const listContentLanguages: (c: Context, tx?: ContentDatabase) => Promise<ContentLanguage[]>;
+export declare const findContentLanguage: (c: Context, locale: string, tx?: ContentDatabase) => Promise<ContentLanguage | null>;
+export declare const resolveContentLanguage: (c: Context, { contentTypeId, locale, requireEnabled, tx, }: {
+    contentTypeId?: string;
+    locale: string;
+    requireEnabled?: boolean;
+    tx?: ContentDatabase;
+}) => Promise<ContentLanguage>;
+export declare const resolveDefaultContentLanguage: (c: Context, definition: AnyContentTypeDefinition, tx?: ContentDatabase) => Promise<ContentLanguage>;
+export interface ContentLocalizationProblem {
+    contentTypeId: string;
+    defaultLocale: string;
+    reason: "disabled" | "missing";
+}
+export declare const findContentLocalizationProblems: (c: Context, contentTypes: readonly RegisteredContentType[]) => Promise<ContentLocalizationProblem[]>;
+export declare const assertContentLocalizationLanguages: (c: Context, contentTypes: readonly RegisteredContentType[]) => Promise<void>;
+export declare const ensureContentLocalizationLanguages: (c: Context, contentTypes: readonly RegisteredContentType[]) => Promise<void>;
+export declare const resetContentLocalizationCheck: () => void;
+export declare const contentDatabase: (c: Context, tx?: ContentDatabase) => ContentDatabase;
+//# sourceMappingURL=language-resolver.d.ts.map

package/dist/src/content/server/language-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-resolver.d.ts","sourceRoot":"","sources":["../../../../src/content/server/language-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAajD,MAAM,WAAW,eAAe;IAE9B,EAAE,EAAE,MAAM,CAAC;IAEX,SAAS,EAAE,OAAO,CAAC;IAEnB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AA0ED,eAAO,MAAM,oBAAoB,GAC/B,GAAG,OAAO,EACV,KAAK,eAAe,KACnB,OAAO,CAAC,eAAe,EAAE,CAe3B,CAAC;AAUF,eAAO,MAAM,mBAAmB,GAC9B,GAAG,OAAO,EACV,QAAQ,MAAM,EACd,KAAK,eAAe,KACnB,OAAO,CAAC,eAAe,GAAG,IAAI,CAShC,CAAC;AAUF,eAAO,MAAM,sBAAsB,GACjC,GAAG,OAAO,EACV,gDAKG;IACD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB,EAAE,CAAC,EAAE,eAAe,CAAC;CACtB,KACA,OAAO,CAAC,eAAe,CAoBzB,CAAC;AASF,eAAO,MAAM,6BAA6B,GACxC,GAAG,OAAO,EACV,YAAY,wBAAwB,EACpC,KAAK,eAAe,KACnB,OAAO,CAAC,eAAe,CAczB,CAAC;AAGF,MAAM,WAAW,0BAA0B;IACzC,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC;CAChC;AAgBD,eAAO,MAAM,+BAA+B,GAC1C,GAAG,OAAO,EACV,cAAc,SAAS,qBAAqB,EAAE,KAC7C,OAAO,CAAC,0BAA0B,EAAE,CAmCtC,CAAC;AAiBF,eAAO,MAAM,kCAAkC,GAC7C,GAAG,OAAO,EACV,cAAc,SAAS,qBAAqB,EAAE,KAC7C,OAAO,CAAC,IAAI,CASd,CAAC;AAeF,eAAO,MAAM,kCAAkC,GAC7C,GAAG,OAAO,EACV,cAAc,SAAS,qBAAqB,EAAE,KAC7C,OAAO,CAAC,IAAI,CASd,CAAC;AAGF,eAAO,MAAM,6BAA6B,QAAO,IAEhD,CAAC;AAQF,eAAO,MAAM,eAAe,GAC1B,GAAG,OAAO,EACV,KAAK,eAAe,KACnB,eAAoC,CAAC"}

package/dist/src/content/server/language-resolver.js

@@ -0,0 +1,2 @@
+import{core_languages}from"../../database/languages.js";import{ContentEngineError,ContentLanguageError}from"../errors.js";const perRequest=new WeakMap;const disabledLocales=c=>{const locales=c.get("core")?.i18n?.locales??[];return new Set(locales.filter(locale=>locale.enabled===false).map(locale=>locale.code.toLowerCase()))};const load=async(c,tx)=>{const disabled=disabledLocales(c);const rows=await contentDatabase(c,tx).select({code:core_languages.code,id:core_languages.id,isDefault:core_languages.default}).from(core_languages);return rows.map(row=>({id:row.id,isDefault:row.isDefault,isEnabled:!disabled.has(row.code.toLowerCase()),locale:row.code}))};export const listContentLanguages=async(c,tx)=>{const cached=perRequest.get(c);if(cached)return await cached;const pending=load(c,tx);perRequest.set(c,pending);try{return await pending}catch(error){perRequest.delete(c);throw error}};export const findContentLanguage=async(c,locale,tx)=>{const wanted=locale.trim().toLowerCase();if(wanted==="")return null;const languages=await listContentLanguages(c,tx);return languages.find(language=>language.locale.toLowerCase()===wanted)??null};export const resolveContentLanguage=async(c,{contentTypeId,locale,requireEnabled=false,tx})=>{const language=await findContentLanguage(c,locale,tx);if(!language){throw new ContentLanguageError({contentTypeId,locale,reason:"missing"})}if(requireEnabled&&!language.isEnabled){throw new ContentLanguageError({contentTypeId,locale:language.locale,reason:"disabled"})}return language};export const resolveDefaultContentLanguage=async(c,definition,tx)=>{if(!definition.localization.enabled){throw new ContentEngineError("This content type has no `localization` block, so it has no default locale.",{contentTypeId:definition.id})}return await resolveContentLanguage(c,{contentTypeId:definition.id,locale:definition.localization.defaultLocale,requireEnabled:true,tx})};export const findContentLocalizationProblems=async(c,contentTypes)=>{const localized=contentTypes.filter(entry=>entry.definition.localization.enabled);if(localized.length===0)return[];const languages=await listContentLanguages(c);const byLocale=new Map(languages.map(language=>[language.locale.toLowerCase(),language]));const problems=[];for(const{definition}of localized){const{defaultLocale}=definition.localization;const language=byLocale.get(defaultLocale.trim().toLowerCase());if(!language){problems.push({contentTypeId:definition.id,defaultLocale,reason:"missing"});continue}if(!language.isEnabled){problems.push({contentTypeId:definition.id,defaultLocale,reason:"disabled"})}}return problems};const describeProblem=problem=>`${problem.contentTypeId} -> localization.defaultLocale "${problem.defaultLocale}" ${problem.reason==="missing"?"does not exist in core_languages":"is disabled in this app's i18n.locales"}`;export const assertContentLocalizationLanguages=async(c,contentTypes)=>{const problems=await findContentLocalizationProblems(c,contentTypes);if(problems.length===0)return;throw new ContentEngineError(`Localized content types have an unusable default locale:
+  ${problems.map(describeProblem).join("\n  ")}`)};let bootCheck;export const ensureContentLocalizationLanguages=async(c,contentTypes)=>{bootCheck??=assertContentLocalizationLanguages(c,contentTypes).catch(error=>{bootCheck=undefined;throw error});await bootCheck};export const resetContentLocalizationCheck=()=>{bootCheck=undefined};export const contentDatabase=(c,tx)=>tx??c.get("db");

package/dist/src/content/server/localized-admin-routes.d.ts

@@ -0,0 +1,99 @@
+import { z } from "@hono/zod-openapi";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentModel } from "./model";
+export declare const buildContentLocalizedAdminRoutes: <TDefinition extends AnyContentTypeDefinition, P extends string>(model: ContentModel<TDefinition>, { pluginId }: {
+    pluginId: P;
+}) => (import("../../api/lib/route").Route<P, {
+    method: "post";
+    path: "/localized";
+    description: string;
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+        };
+    };
+    responses: {
+        201: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        } | {
+            description: string;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}> | import("../../api/lib/route").Route<P, {
+    method: "put";
+    path: "/{id}/localized";
+    description: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodCoercedNumber;
+        }, z.core.$strip>;
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        } | {
+            description: string;
+        };
+        404: {
+            description: string;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>)[];
+//# sourceMappingURL=localized-admin-routes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"localized-admin-routes.d.ts","sourceRoot":"","sources":["../../../../src/content/server/localized-admin-routes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAGtC,OAAO,KAAK,EACV,wBAAwB,EAKzB,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAiD5C,eAAO,MAAM,gCAAgC,GAC3C,WAAW,SAAS,wBAAwB,EAC5C,CAAC,SAAS,MAAM,EAEhB,OAAO,YAAY,CAAC,WAAW,CAAC,EAChC,cAAc;IAAE,QAAQ,EAAE,CAAC,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAod9B,CAAC"}

package/dist/src/content/server/localized-admin-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{zodContentConflict,zodContentDeliveryConflict,zodContentTranslationConflict}from"../conflicts.js";import{CONTENT_LOCALE_MAX_LENGTH,CONTENT_PERMISSIONS}from"../const.js";import{zodContentFileReferenceRejection}from"../files.js";import{resolveContentActor}from"./actor.js";import{contentEditorialEffects}from"./editorial-effects.js";import{emitContentEvent}from"./emit.js";import{contentFileFields}from"./files.js";import{withHttpErrors}from"./http-errors.js";import{contentSearchAdvancedValues,syncContentSearch}from"./search-sync.js";import{contentTranslationEffects}from"./translation-effects.js";import{withTranslationHttpErrors}from"./translation-http-errors.js";export const buildContentLocalizedAdminRoutes=(model,{pluginId})=>{const{definition,schemas}=model;const translationSchemas=model.translationSchemas;const buildTranslations=model.translationService;if(!translationSchemas||!buildTranslations){throw new Error(`[Content Engine] ${definition.id}: buildContentLocalizedAdminRoutes needs a localized content type.`)}const module=definition.permissionModule;const name=contentTypeName(definition.id);const editorial=definition.editorial.enabled;const{defaultLocale}=definition.localization;const jsonBody=schema=>({content:{"application/json":{schema}}});const jsonResponse=(schema,description)=>({content:{"application/json":{schema}},description});const writeRejection=description=>Object.keys(contentFileFields(definition)).length>0?jsonResponse(zodContentFileReferenceRejection,`${description}, or a file this field may not hold`):{description};const conflict=jsonResponse(z.union([zodContentConflict,zodContentTranslationConflict,zodContentDeliveryConflict]),"The record moved, a translation moved, or a value is taken");const translationEntry=z.object({expectedVersion:z.number().int().positive().optional(),locale:z.string().min(1).max(CONTENT_LOCALE_MAX_LENGTH),values:translationSchemas.createObject.partial()});const createBody=z.object({translations:z.array(translationEntry),values:schemas.create});const updateBody=z.object({expectedVersion:z.number().int().positive().optional(),translations:z.array(translationEntry),values:schemas.update.optional()});const readJson=async(c,schema)=>schema.parse(await c.req.json());const identifier=c=>{const value=Number(c.req.param("id"));if(!Number.isInteger(value)||value<=0){throw new HTTPException(400,{message:"Invalid identifier."})}return value};const sameLocale=(left,right)=>left.toLowerCase()===right.toLowerCase();const plainOutcome=(operation,row,{changed=true,changedFields=[]}={})=>({changed,changedFields,languageId:row.languageId,locale:row.locale,operation,previousSlug:null,restoredFromRevisionId:null,revisionId:null,row,version:row.version});const writeTranslation=async(c,itemId,entry,tx)=>{const buildEditorial=model.translationEditorialService;const translations=buildTranslations(c);return await withTranslationHttpErrors(entry.expectedVersion===undefined?"create":"update",async()=>{if(entry.expectedVersion===undefined){const complete=translationSchemas.createObject.parse(entry.values);if(buildEditorial){return await buildEditorial(c,{pluginId}).create(itemId,entry.locale,complete,{actor:resolveContentActor(c),tx})}return plainOutcome("create",await translations.create(itemId,entry.locale,complete,{tx}))}const patch=entry.values;if(buildEditorial){return await buildEditorial(c,{pluginId}).update(itemId,entry.locale,patch,{actor:resolveContentActor(c),expectedVersion:entry.expectedVersion,tx})}const result=await translations.update(itemId,entry.locale,patch,{expectedVersion:entry.expectedVersion,tx});return result?plainOutcome("update",result.row,{changed:result.changed,changedFields:result.changedFields}):null},{contentTypeId:definition.id,itemId,locale:entry.locale})};const editorialService=c=>{const build=model.editorialService;if(!build){throw new HTTPException(500,{message:"This content type has no editorial workflow."})}return build(c,{pluginId})};const announceShared=async(c,outcome,row,operation,changedFields)=>{if(outcome){await contentEditorialEffects(c,definition,outcome,{model,pluginId});return}const id=row.id;await emitContentEvent(c,definition,operation==="create"?"created":"updated",operation==="create"?{contentId:id}:{changedFields:[...changedFields],contentId:id},{pluginId});await syncContentSearch(c,definition,{advanced:await contentSearchAdvancedValues(c,model,id),changedFields:[...changedFields],operation,pluginId,row})};const create=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.create},route:{method:"post",path:"/localized",description:`Create a ${name} with its translations`,request:{body:jsonBody(createBody)},responses:{201:jsonResponse(schemas.selectObject,`${name} created successfully`),400:writeRejection("Invalid input data"),409:conflict}},handler:async c=>{const body=await readJson(c,createBody);const entries=body.translations;if(!entries.some(entry=>sameLocale(entry.locale,defaultLocale))){throw new HTTPException(400,{message:`A ${name} is created in its default language "${defaultLocale}". Fill in its required fields in that language.`})}const ordered=[...entries].sort((left,right)=>sameLocale(left.locale,defaultLocale)?-1:sameLocale(right.locale,defaultLocale)?1:0);const result=await withHttpErrors("create",async()=>await c.get("db").transaction(async tx=>{const outcome=editorial?await editorialService(c).create(body.values,{actor:resolveContentActor(c),tx}):null;const row=outcome?.row??await model.service(c).create(body.values,{tx});const written=[];for(const entry of ordered){const translated=await writeTranslation(c,row.id,entry,tx);if(translated)written.push(translated)}return{outcome,row,written}}),{contentTypeId:definition.id,structured:editorial});await announceShared(c,result.outcome,result.row,"create",[]);for(const written of result.written){await contentTranslationEffects(c,definition,written,{model,pluginId})}return c.json(result.row,201)}});const update=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.edit},route:{method:"put",path:"/{id}/localized",description:`Update a ${name} and its translations`,request:{params:schemas.params,body:jsonBody(updateBody)},responses:{200:jsonResponse(schemas.selectObject,`${name} updated successfully`),400:writeRejection("Invalid or empty payload"),404:{description:`${name} not found`},409:conflict}},handler:async c=>{const id=identifier(c);const body=await readJson(c,updateBody);const entries=body.translations;const shared=body.values;if(editorial&&shared!==undefined&&body.expectedVersion===undefined){throw new HTTPException(400,{message:"expectedVersion is required to change a shared field."})}const result=await withHttpErrors("update",async()=>await c.get("db").transaction(async tx=>{let outcome=null;let changedFields=[];let row=null;if(shared!==undefined){if(editorial){outcome=await editorialService(c).update(id,shared,{actor:resolveContentActor(c),expectedVersion:body.expectedVersion??0,tx});if(!outcome)return null;changedFields=outcome.changedFields;row=outcome.row}else{const plain=await model.service(c).update(id,shared,{tx});if(!plain)return null;changedFields=plain.changedFields;row=plain.row}}const written=[];for(const entry of entries){const translated=await writeTranslation(c,id,entry,tx);if(translated)written.push(translated)}const current=row??await model.service(c).findById(id,{tx});return current===null?null:{changedFields,outcome,row:current,touched:row!==null,written}}),{contentTypeId:definition.id,itemId:id,structured:editorial});if(!result){throw new HTTPException(404,{message:`${name} not found.`})}if(result.touched){await announceShared(c,result.outcome,result.row,"update",result.changedFields)}for(const written of result.written){await contentTranslationEffects(c,definition,written,{model,pluginId})}return c.json(result.row,200)}});return[create,update]};

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

@@ -0,0 +1,15 @@
+import type { PgColumn, PgTable, PgTableWithColumns, TableConfig } from "drizzle-orm/pg-core";
+import type { Context } from "hono";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentAdvancedStore } from "./advanced-store";
+import type { ContentPublicService } from "./public-service";
+export declare const createContentLocalizedPublicService: <TDefinition extends AnyContentTypeDefinition>({ advanced, c, columns, definition, table, translationColumns, translationTable, }: {
+    advanced?: ContentAdvancedStore;
+    c: Context;
+    columns: Record<string, PgColumn>;
+    definition: TDefinition;
+    table: PgTableWithColumns<TableConfig>;
+    translationColumns: Record<string, PgColumn>;
+    translationTable: PgTable;
+}) => ContentPublicService<TDefinition>;
+//# sourceMappingURL=localized-public-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"localized-public-service.d.ts","sourceRoot":"","sources":["../../../../src/content/server/localized-public-service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,QAAQ,EACR,OAAO,EACP,kBAAkB,EAClB,WAAW,EACZ,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AASpC,OAAO,KAAK,EAAE,wBAAwB,EAAuB,MAAM,UAAU,CAAC;AAC9E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AA+F7D,eAAO,MAAM,mCAAmC,GAC9C,WAAW,SAAS,wBAAwB,EAC5C,oFAQC;IAED,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,CAAC,EAAE,OAAO,CAAC;IACX,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAClC,UAAU,EAAE,WAAW,CAAC;IACxB,KAAK,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC;IACvC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC7C,gBAAgB,EAAE,OAAO,CAAC;CAC3B,KAAG,oBAAoB,CAAC,WAAW,CAsfnC,CAAC"}

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

@@ -0,0 +1 @@
+import{and,eq,exists,not,or,sql}from"drizzle-orm";import{alias}from"drizzle-orm/pg-core";import{withPagination}from"../../api/lib/with-pagination.js";import{CONTENT_PUBLIC_DEFAULT_PAGE_SIZE,CONTENT_PUBLIC_MAX_PAGE_SIZE}from"../const.js";import{ContentEngineError}from"../errors.js";import{partitionContentFields}from"../localization.js";import{isContentReferenceCollection,splitContentFieldPath}from"../paths.js";import{publicOrderableColumns}from"../registry.js";import{resolveContentPublicRowFiles}from"./files.js";import{findContentLanguage}from"./language-resolver.js";import{clampContentPublicPageSize,contentPublicCollectionFields,createContentPublicProjector,nestContentPublicRow}from"./public-service.js";import{contentTranslationPublicationColumns,publicationColumns,publishedCondition}from"./publication.js";import{buildFilterCondition,buildOrderColumn,buildSearchCondition}from"./query.js";const LANGUAGE_KEY="_languageId";const conditions=(...parts)=>{const present=parts.filter(part=>part!==undefined);if(present.length===0)return undefined;return present.length===1?present[0]:and(...present)};const anyOf=(...parts)=>{const present=parts.filter(part=>part!==undefined);if(present.length===0)return undefined;return present.length===1?present[0]:or(...present)};const EMPTY_PAGE={count:0,endCursor:null,hasNextPage:false,hasPreviousPage:false,startCursor:null,totalCount:0};export const createContentLocalizedPublicService=({advanced,c,columns,definition,table,translationColumns,translationTable})=>{const contentTypeId=definition.id;const publicApi=definition.publicApi;const localization=definition.localization;if(!publicApi.enabled||!localization.enabled){throw new ContentEngineError("The localized public service needs both `publicApi: { enabled: true, path, fields }` and `localization: { enabled: true, defaultLocale }`.",{contentTypeId})}const{collectionFields,localizedFields,sharedFields}=partitionContentFields(definition.fields);const isLocalized=name=>localizedFields[name]!==undefined;const basePublication=publicationColumns(definition,columns);const translationPublication=contentTranslationPublicationColumns(definition,translationColumns);const primaryCursor=columns.id;const orderable=publicOrderableColumns(definition);const project=createContentPublicProjector(definition);const ownerOf=name=>{const path=splitContentFieldPath(name);return path?path[0]:name};const isColumnField=name=>{const fieldValue=definition.fields[ownerOf(name)];if(!fieldValue)return true;if(fieldValue.kind==="repeatable")return false;return!isContentReferenceCollection(fieldValue)};const exposedColumns=publicApi.fields.filter(isColumnField);const exposedShared=exposedColumns.filter(name=>!isLocalized(ownerOf(name)));const exposedLocalized=exposedColumns.filter(name=>isLocalized(ownerOf(name)));const publicCollections=contentPublicCollectionFields(definition);const localizedColumnByPath=new Map(definition.advanced.leaves.filter(leaf=>leaf.localized).map(leaf=>[leaf.path,leaf.columnName]));const withCollections=async rows=>{const nested=rows.map(nestContentPublicRow);if(nested.length===0)return nested;const ids=nested.map(row=>row.id).filter(id=>typeof id==="number");const loaded=publicCollections.length===0?undefined:await advanced?.loadMany(ids,c.get("db"),publicCollections);const withCollectionValues=loaded===undefined?nested:nested.map(row=>({...row,...typeof row.id==="number"?loaded.get(row.id):undefined}));return await resolveContentPublicRowFiles(c,definition,withCollectionValues)};const sharedSearchable=publicApi.searchableFields.filter(name=>!isLocalized(ownerOf(name)));const localizedSearchable=publicApi.searchableFields.filter(name=>isLocalized(ownerOf(name)));const requestedTable=alias(translationTable,"vn_locale");const fallbackTable=alias(translationTable,"vn_fallback");const requestedRows=requestedTable;const fallbackRows=fallbackTable;const publishedTranslation=(languageId,extra)=>exists(c.get("db").select({one:sql`1`}).from(translationTable).where(conditions(eq(translationColumns.itemId,columns.id),eq(translationColumns.languageId,languageId),publishedCondition(translationPublication),extra)));const visibleIn=({fallbackTo,requested},extra)=>{const direct=publishedTranslation(requested.id,extra);if(!fallbackTo)return direct;return anyOf(direct,conditions(not(publishedTranslation(requested.id)),publishedTranslation(fallbackTo.id,extra)))};const joinOn=(rows,languageId)=>conditions(eq(rows.itemId,columns.id),eq(rows.languageId,languageId),publishedCondition({publishedAt:rows.publishedAt,status:rows.status}));const translationColumnName=name=>localizedColumnByPath.get(name)??name;const localizedValue=(name,withFallback)=>{const column=translationColumnName(name);return withFallback?sql`case when ${requestedRows.itemId} is not null then ${requestedRows[column]} else ${fallbackRows[column]} end`:requestedRows[column]};const selection=withFallback=>({id:columns.id,...Object.fromEntries(exposedShared.map(name=>[name,columns[name]])),...Object.fromEntries(exposedLocalized.map(name=>[name,localizedValue(name,withFallback)])),[LANGUAGE_KEY]:withFallback?sql`case when ${requestedRows.itemId} is not null then ${requestedRows.languageId} else ${fallbackRows.languageId} end`:requestedRows.languageId});const resolveLocale=async locale=>{const requested=await findContentLanguage(c,locale??localization.defaultLocale);if(!requested?.isEnabled)return null;if(localization.fallback!=="default"){return{fallbackTo:null,requested}}const defaultLanguage=await findContentLanguage(c,localization.defaultLocale);if(!defaultLanguage||defaultLanguage.id===requested.id){return{fallbackTo:null,requested}}return{fallbackTo:defaultLanguage,requested}};const projectRow=(row,{fallbackTo,requested})=>({...project(row),locale:fallbackTo!==null&&row[LANGUAGE_KEY]===fallbackTo.id?fallbackTo.locale:requested.locale});const read=async(scope,where,{cursorSelection,limit,order})=>{const query=c.get("db").select({...selection(scope.fallbackTo!==null),...cursorSelection}).from(table);if(!scope.fallbackTo){const scoped=query.innerJoin(requestedTable,joinOn(requestedRows,scope.requested.id)).where(where);return order?await scoped.orderBy(order).limit(limit):await scoped.limit(limit)}const scoped=query.leftJoin(requestedTable,joinOn(requestedRows,scope.requested.id)).leftJoin(fallbackTable,joinOn(fallbackRows,scope.fallbackTo.id)).where(where);return order?await scoped.orderBy(order).limit(limit):await scoped.limit(limit)};const readOne=async(resolved,condition,{strict=false}={})=>{const scope=strict?{fallbackTo:null,requested:resolved.requested}:resolved;const[row]=await read(scope,conditions(publishedCondition(basePublication),visibleIn(scope),condition),{limit:1});if(!row)return null;const[withAdvanced]=await withCollections([row]);return projectRow(withAdvanced,scope)};return{findById:async(id,options)=>{const resolved=await resolveLocale(options?.locale);if(!resolved)return null;return await readOne(resolved,eq(columns.id,id))},findBySlug:async(slug,options)=>{const resolved=await resolveLocale(options?.locale);if(!resolved)return null;const slugField=publicApi.slugField;const condition=isLocalized(slugField)?publishedTranslation(resolved.requested.id,eq(translationColumns[slugField],slug)):eq(columns[slugField],slug);return await readOne(resolved,condition,{strict:true})},findMany:async({filters={},locale,orderBy,query={}}={})=>{const resolved=await resolveLocale(locale);if(!resolved)return{edges:[],pageInfo:EMPTY_PAGE};const raw=filters;const sharedFilters=Object.fromEntries(Object.entries(raw).filter(([name])=>!isLocalized(ownerOf(name))));const localizedFilters=Object.fromEntries(Object.entries(raw).filter(([name])=>isLocalized(ownerOf(name))));const term=query.search;const sharedSearch=buildSearchCondition(sharedSearchable.map(name=>columns[name]),term);const localizedSearch=buildSearchCondition(localizedSearchable.map(name=>translationColumns[name]),term);const where=conditions(publishedCondition(basePublication),visibleIn(resolved,buildFilterCondition({allowed:publicApi.filterableFields,columns:translationColumns,contentTypeId,fields:localizedFields,filters:localizedFilters})),buildFilterCondition({allowed:publicApi.filterableFields,columns,contentTypeId,fields:{...collectionFields,...sharedFields},filters:sharedFilters,membership:advanced?.membershipCondition}),anyOf(sharedSearch,localizedSearch===undefined?undefined:visibleIn(resolved,localizedSearch)));const data=await withPagination({c,params:{query:{...query,first:clampContentPublicPageSize(query.first),last:clampContentPublicPageSize(query.last),search:undefined}},primaryCursor,orderBy:{column:buildOrderColumn({columns,contentTypeId,fallback:publicApi.defaultOrderBy,orderBy:orderBy?.column,orderable}),order:orderBy?.order??publicApi.defaultOrder},table,where,query:async({cursorSelection,limit,orderBy:order,where:paged})=>await read(resolved,paged,{cursorSelection,limit:typeof limit==="number"?Math.min(limit,CONTENT_PUBLIC_MAX_PAGE_SIZE+1):CONTENT_PUBLIC_DEFAULT_PAGE_SIZE,order})});return{edges:(await withCollections(data.edges)).map(row=>projectRow(row,resolved)),pageInfo:data.pageInfo}}}};