@vitnode/core 0.0.1-canary.0

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}}}};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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