@vitnode/core 0.0.1-canary.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../../src/content/server/routes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAItC,OAAO,KAAK,EACV,wBAAwB,EAIzB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAmB,YAAY,EAAE,MAAM,SAAS,CAAC;AA2H7D,eAAO,MAAM,kBAAkB,GAC7B,WAAW,SAAS,wBAAwB,EAC5C,CAAC,SAAS,MAAM,EAEhB,OAAO,YAAY,CAAC,WAAW,CAAC,EAChC,cAAc;IAAE,QAAQ,EAAE,CAAC,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAglD9B,CAAC"}

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

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{HTTPException}from"hono/http-exception";import{checkStaffPermission}from"../../api/lib/check-staff-permission.js";import{buildRoute}from"../../api/lib/route.js";import{zodPaginationPageInfo,zodPaginationQuery}from"../../api/lib/with-pagination.js";import{StorageImageUnprocessableError}from"../../api/models/storage.js";import{contentTypeName}from"../admin/labels.js";import{zodContentConflict,zodContentDeliveryConflict,zodContentScheduleRejection,zodContentUnprocessable}from"../conflicts.js";import{CONTENT_ACTOR_TYPES,CONTENT_FILE_CODES,CONTENT_LOCALE_MAX_LENGTH,CONTENT_OPTIONS_LIMIT,CONTENT_PERMISSIONS,CONTENT_REVISION_OPERATIONS,CONTENT_SCHEDULE_ACTIONS,CONTENT_SCHEDULE_STATUSES}from"../const.js";import{contentFileConstraints,contentFileFolder,validateContentFile,zodContentFileDescriptor,zodContentFileFieldValue,zodContentFileReferenceRejection}from"../files.js";import{partitionContentFields}from"../localization.js";import{orderableColumns}from"../registry.js";import{resolveContentActor}from"./actor.js";import{contentEditorialEffects}from"./editorial-effects.js";import{emitContentEvent}from"./emit.js";import{contentFileDescriptorFromUpload,contentFileFields,withContentRowFiles}from"./files.js";import{withHttpErrors}from"./http-errors.js";import{findContentLanguage}from"./language-resolver.js";import{buildContentLocalizedAdminRoutes}from"./localized-admin-routes.js";import{assertContentPreviewIsServable,contentPreviewSecret,contentPreviewUrl}from"./preview-link.js";import{resolveContentPreviewTarget}from"./preview-target.js";import{createContentPreviewToken}from"./preview-token.js";import{publicationMethods}from"./publication.js";import{CONTENT_REVISIONS_MAX_PAGE_SIZE}from"./revisions-model.js";import{contentSearchAdvancedValues,syncContentSearch}from"./search-sync.js";import{buildContentTranslationRoutes}from"./translation-routes.js";const zodLabels=z.record(z.string(),z.string().nullable());const zodOptions=z.object({items:z.array(z.object({avatarColor:z.string().optional(),color:z.string().optional(),label:z.string(),nameCode:z.string().optional(),value:z.number()}))});const notFound=definition=>new HTTPException(404,{message:`${contentTypeName(definition.id)} not found.`});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 advancedForSearch=async(c,model,row)=>{const id=row.id;return typeof id==="number"?await contentSearchAdvancedValues(c,model,id):undefined};export const buildContentRoutes=(model,{pluginId})=>{const{definition,schemas}=model;const module=definition.permissionModule;const name=contentTypeName(definition.id);const localized=definition.localization.enabled;const fileFields=contentFileFields(definition);const hasFileFields=Object.keys(fileFields).length>0;const zodFiles=z.record(z.string(),zodContentFileFieldValue);const withFiles=async(c,rows)=>hasFileFields?await withContentRowFiles(c,definition,rows):[...rows];const zodRowTranslation=z.object({locale:z.string(),publishedAt:z.date().nullable().optional(),status:z.string().optional(),title:z.string(),values:z.record(z.string(),z.unknown()),version:z.number()}).nullable();const detailRow=schemas.selectObject.extend({labels:zodLabels,...hasFileFields?{files:zodFiles}:{},...schemas.advancedSelect.shape});const listRow=schemas.selectObject.extend({labels:zodLabels,...hasFileFields?{files:zodFiles}:{},...localized?{translation:zodRowTranslation.optional()}:{}});const publicationResponse=z.object({changed:z.boolean(),row:schemas.selectObject});const referenceFieldNames=Object.entries(definition.fields).filter(([,fieldValue])=>fieldValue.kind==="relation"||fieldValue.kind==="user").map(([name])=>name);const isReferenceField=value=>referenceFieldNames.includes(value);const readJson=async(c,schema)=>schema.parse(await c.req.json());const orderable=orderableColumns(definition);const paginationQuery=zodPaginationQuery.extend({order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(orderable).optional(),search:z.string().optional()});const jsonBody=schema=>({content:{"application/json":{schema}}});const jsonResponse=(schema,description)=>({content:{"application/json":{schema}},description});const invalidIdentifier={description:"Invalid identifier"};const editorial=definition.editorial.enabled;const writeRejection=description=>hasFileFields?jsonResponse(zodContentFileReferenceRejection,`${description}, or a file this field may not hold`):{description};const conflictSchema=definition.delivery.enabled&&definition.delivery.redirects.enabled?z.union([zodContentConflict,zodContentDeliveryConflict]):zodContentConflict;const uniqueConflict=editorial?jsonResponse(conflictSchema,definition.delivery.redirects.enabled?"A record with these values already exists, the version moved, or the address is reserved by a historical URL":"A record with these values already exists, or the version moved"):{description:"A record with these values already exists"};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 previewEnabled=definition.editorial.preview.enabled;const previewSecret=contentPreviewSecret;const previewUrl=(token,target)=>contentPreviewUrl({definition,locale:target.locale,pluginId,slug:target.slug,token});const assertPreviewIsServable=assertContentPreviewIsServable;const list=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.view},route:{method:"get",path:"/",description:`List ${name} records`,request:{query:paginationQuery.extend({...schemas.filters.shape,...localized?{locale:z.string().min(1).max(CONTENT_LOCALE_MAX_LENGTH).optional()}:{}})},responses:{200:jsonResponse(z.object({edges:z.array(listRow),pageInfo:zodPaginationPageInfo}),`${name} records retrieved successfully`),400:{description:"Invalid query parameters"}}},handler:async c=>{const raw=c.req.query();const{cursor,first,last,order,orderBy,search}=paginationQuery.parse(raw);const filters=schemas.filters.parse(raw);const data=await model.service(c).findMany({filters,orderBy:{column:orderBy,order},query:{cursor,first,last,search}});const withTranslations=await withRowTranslations(c,data,raw.locale);return c.json({...withTranslations,edges:await withFiles(c,withTranslations.edges)},200)}});const withRowTranslations=async(c,data,locale)=>{const build=model.translationService;if(!localized||!build||locale===undefined||locale.trim()===""){return data}const language=await findContentLanguage(c,locale);if(!language){return{...data,edges:data.edges.map(row=>({...row,translation:null}))}}const translations=build(c);const titleField=Object.entries(partitionContentFields(definition.fields).localizedFields).find(([,fieldValue])=>fieldValue.kind==="text")?.[0]??null;const rows=await translations.findManyByLanguageId(data.edges.map(row=>row.id),language.id);const byId=new Map(rows.map(row=>[row.itemId,row]));return{...data,edges:data.edges.map(row=>{const translation=byId.get(row.id);if(!translation)return{...row,translation:null};const values=translation.values;const meta=translation;return{...row,translation:{locale:translation.locale,...definition.publication.enabled?{publishedAt:meta.publishedAt,status:meta.status}:{},title:titleField===null?"":typeof values[titleField]==="string"?values[titleField]:"",values,version:translation.version}}})}};const options=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.view},route:{method:"get",path:"/options/{field}",description:`Picker options for a ${name} relation`,request:{params:z.object({field:z.string()}),query:z.object({ids:z.string().optional(),search:z.string().optional()})},responses:{200:jsonResponse(zodOptions,`Up to ${CONTENT_OPTIONS_LIMIT} options`),400:{description:"Not a relation or user field"}}},handler:async c=>{const field=c.req.param("field");if(!isReferenceField(field)){throw new HTTPException(400,{message:"This field has no picker."})}const raw=c.req.query("ids");const ids=raw===undefined?undefined:raw.split(",").map(value=>Number(value.trim())).filter(value=>Number.isInteger(value));const items=await model.service(c).options(field,c.req.query("search"),ids);return c.json({items},200)}});const uploadForm=z.object({file:z.instanceof(File).openapi({format:"binary",type:"string"})});const zodFileRejection=z.object({code:z.string(),message:z.string()});const upload=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.view},route:{method:"post",path:"/uploads/{field}",description:`Upload a file for one ${name} file field`,request:{params:z.object({field:z.string()}),body:{required:true,content:{"multipart/form-data":{schema:uploadForm}}}},responses:{200:jsonResponse(zodContentFileDescriptor,"File stored and recorded in core_files"),400:jsonResponse(zodFileRejection,"Not a file field, or the file failed the field's own rules"),403:jsonResponse(zodFileRejection,"Not allowed to write this content type"),500:jsonResponse(zodFileRejection,"The install cannot store files - no adapter, or the image pipeline failed")}},handler:async c=>{const field=c.req.param("field");const fieldValue=fileFields[field];if(!fieldValue){return c.json({code:CONTENT_FILE_CODES.unknownField,message:`"${field}" is not a file field on this content type.`},400)}const allowed=await Promise.all([CONTENT_PERMISSIONS.create,CONTENT_PERMISSIONS.edit].map(async permission=>await checkStaffPermission(c,{module,permission,plugin:pluginId,type:"admin"})));if(!allowed.some(Boolean)){return c.json({code:CONTENT_FILE_CODES.forbidden,message:`You do not have permission to upload a ${name}.`},403)}const{file}=uploadForm.parse(await c.req.parseBody());const constraints=contentFileConstraints(fieldValue);const rejected=validateContentFile(constraints,{mimeType:file.type===""?null:file.type,name:file.name,size:file.size});if(rejected)return c.json(rejected,400);let stored;try{stored=await c.get("storage").upload({file,folder:contentFileFolder({module,pluginId}),...constraints.allowedMimeTypes?{allowedMimeTypes:[...constraints.allowedMimeTypes]}:{},maxBytes:constraints.maxBytes,metadata:{contentTypeId:definition.id,field}})}catch(error){if(!(error instanceof HTTPException))throw error;const code=error instanceof StorageImageUnprocessableError?CONTENT_FILE_CODES.unprocessable:error.status===400?CONTENT_FILE_CODES.invalid:CONTENT_FILE_CODES.storage;return c.json({code,message:error.message},error.status===400?400:500)}const descriptor=contentFileDescriptorFromUpload(stored);const stale=validateContentFile(constraints,descriptor);if(stale){await c.get("storage").deleteFile(stored.id);return c.json({code:stale.code,message:`${stale.message} The stored file is "${descriptor.name}" (${descriptor.mimeType??"unknown type"}). Image processing re-encodes uploads to WebP, and keeps an image too large for WebP in its original format - so this field's allowlist has to accept both.`},400)}return c.json(descriptor,200)}});const detail=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.view},route:{method:"get",path:"/{id}",description:`Get one ${name}`,request:{params:schemas.params},responses:{200:jsonResponse(detailRow,`${name} found`),400:invalidIdentifier,404:{description:`${name} not found`}}},handler:async c=>{const id=identifier(c);const service=model.service(c);const row=await service.findRowById(id);if(!row)throw notFound(definition);const[withFileDescriptors]=await withFiles(c,[{...row,...await service.advanced(id)}]);return c.json(withFileDescriptors,200)}});const create=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.create},route:{method:"post",path:"/",description:`Create a ${name}`,request:{body:jsonBody(schemas.create)},responses:{201:jsonResponse(schemas.selectObject,`${name} created successfully`),400:writeRejection("Invalid input data"),409:uniqueConflict}},handler:async c=>{const values=await readJson(c,schemas.create);if(editorial){const result=await withHttpErrors("create",async()=>await editorialService(c).create(values,{actor:resolveContentActor(c)}),{contentTypeId:definition.id,structured:true});await contentEditorialEffects(c,definition,result,{model,pluginId});return c.json(result.row,201)}const row=await withHttpErrors("create",async()=>model.service(c).create(values));await emitContentEvent(c,definition,"created",{contentId:row.id},{pluginId});await syncContentSearch(c,definition,{advanced:await advancedForSearch(c,model,row),operation:"create",pluginId,row});return c.json(row,201)}});const editorialUpdate=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.edit},route:{method:"put",path:"/{id}",description:`Update a ${name}`,request:{params:schemas.params,body:jsonBody(schemas.updateEnvelope)},responses:{200:jsonResponse(schemas.selectObject,`${name} updated successfully`),400:writeRejection("Invalid or empty payload"),404:{description:`${name} not found`},409:uniqueConflict}},handler:async c=>{const id=identifier(c);const{expectedVersion,values}=await readJson(c,schemas.updateEnvelope);const result=await withHttpErrors("update",async()=>await editorialService(c).update(id,values,{actor:resolveContentActor(c),expectedVersion}),{contentTypeId:definition.id,itemId:id,structured:true});if(!result)throw notFound(definition);await contentEditorialEffects(c,definition,result,{model,pluginId});return c.json(result.row,200)}});const update=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.edit},route:{method:"put",path:"/{id}",description:`Update a ${name}`,request:{params:schemas.params,body:jsonBody(schemas.update)},responses:{200:jsonResponse(schemas.selectObject,`${name} updated successfully`),400:writeRejection("Invalid or empty payload"),404:{description:`${name} not found`},409:uniqueConflict}},handler:async c=>{const values=await readJson(c,schemas.update);const result=await withHttpErrors("update",async()=>model.service(c).update(identifier(c),values));if(!result)throw notFound(definition);if(result.changedFields.length>0){await emitContentEvent(c,definition,"updated",{changedFields:result.changedFields,contentId:result.row.id},{pluginId})}await syncContentSearch(c,definition,{advanced:await advancedForSearch(c,model,result.row),changedFields:result.changedFields,operation:"update",pluginId,row:result.row});return c.json(result.row,200)}});const publicationRoute=action=>buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.publish},route:{method:"post",path:`/{id}/${action}`,description:`${action==="publish"?"Publish":"Unpublish"} a ${name}`,request:{params:schemas.params},responses:{200:jsonResponse(publicationResponse,`${name} ${action}ed, or already in that state`),400:invalidIdentifier,404:{description:`${name} not found`}}},handler:async c=>{const id=identifier(c);if(editorial){const result=await withHttpErrors("update",async()=>await editorialService(c)[action](id,{actor:resolveContentActor(c)}),{contentTypeId:definition.id,itemId:id,structured:true});if(!result)throw notFound(definition);await contentEditorialEffects(c,definition,result,{model,pluginId});return c.json({changed:result.changed,row:result.row},200)}const service=publicationMethods(definition,model.service(c));const result=await withHttpErrors("update",async()=>await service[action](id));if(!result)throw notFound(definition);if(result.changed){await emitContentEvent(c,definition,action==="publish"?"published":"unpublished",action==="publish"&&result.publishedAt?{contentId:id,publishedAt:result.publishedAt}:{contentId:id},{pluginId})}await syncContentSearch(c,definition,{advanced:await advancedForSearch(c,model,result.row),changed:result.changed,operation:action,pluginId,row:result.row});return c.json({changed:result.changed,row:result.row},200)}});const zodRevisionMeta=z.object({actorName:z.string().nullable(),actorRoleColor:z.string().nullable(),actorType:z.enum(CONTENT_ACTOR_TYPES),actorUserId:z.number().nullable(),changedFields:z.array(z.string()),createdAt:z.union([z.date(),z.string()]),id:z.number(),operation:z.enum(CONTENT_REVISION_OPERATIONS),restoredFromRevisionId:z.number().nullable(),version:z.number()});const zodRevisionDetail=zodRevisionMeta.extend({snapshot:z.object({}).loose()});const revisionParams=z.object({id:z.coerce.number(),revisionId:z.coerce.number()});const revisionIdentifier=c=>{const value=Number(c.req.param("revisionId"));if(!Number.isInteger(value)||value<=0){throw new HTTPException(400,{message:"Invalid revision identifier."})}return value};const revisionQuery=z.object({cursor:z.coerce.number().int().positive().optional(),first:z.coerce.number().int().min(1).max(CONTENT_REVISIONS_MAX_PAGE_SIZE).optional()});const revisionList=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.view},route:{method:"get",path:"/{id}/revisions",description:`History of one ${name}`,request:{params:schemas.params,query:revisionQuery},responses:{200:jsonResponse(z.object({edges:z.array(zodRevisionMeta),pageInfo:z.object({endCursor:z.number().nullable(),hasNextPage:z.boolean()})}),"Revisions, newest first"),400:{description:"Invalid query parameters"}}},handler:async c=>{const{cursor,first}=revisionQuery.parse(c.req.query());const page=await editorialService(c).revisions.list(identifier(c),{cursor,limit:first});return c.json(page,200)}});const revisionDetail=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.view},route:{method:"get",path:"/{id}/revisions/{revisionId}",description:`One revision of a ${name}, with its snapshot`,request:{params:revisionParams},responses:{200:jsonResponse(zodRevisionDetail,"Revision found"),400:invalidIdentifier,404:{description:"Revision not found"}}},handler:async c=>{const revision=await editorialService(c).revisions.findById(identifier(c),revisionIdentifier(c));if(!revision){throw new HTTPException(404,{message:"Revision not found."})}return c.json(revision,200)}});const restore=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.restore},route:{method:"post",path:"/{id}/revisions/{revisionId}/restore",description:`Restore a ${name} to an earlier revision`,request:{params:revisionParams,body:jsonBody(z.strictObject({expectedVersion:z.number().int().positive()}))},responses:{200:jsonResponse(z.object({changed:z.boolean(),row:schemas.selectObject}),`${name} restored, or already at those values`),400:invalidIdentifier,404:{description:"Revision not found"},409:uniqueConflict,422:jsonResponse(zodContentUnprocessable,"The revision no longer fits this content type")}},handler:async c=>{const id=identifier(c);const revisionId=revisionIdentifier(c);const{expectedVersion}=await readJson(c,z.strictObject({expectedVersion:z.number().int().positive()}));const result=await withHttpErrors("update",async()=>await editorialService(c).restore(id,revisionId,{actor:resolveContentActor(c),expectedVersion}),{contentTypeId:definition.id,itemId:id,structured:true});if(!result){throw new HTTPException(404,{message:"Revision not found."})}await contentEditorialEffects(c,definition,result,{model,pluginId});return c.json({changed:result.changed,row:result.row},200)}});const deliveryDetail=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.view},route:{method:"get",path:"/{id}/delivery",description:`Canonical URL and historical URLs of one ${name}`,request:{params:schemas.params,query:z.object({locale:z.string().min(1).max(CONTENT_LOCALE_MAX_LENGTH).optional()})},responses:{200:jsonResponse(z.object({canonicalPath:z.string().nullable(),history:z.array(z.object({createdAt:z.date(),path:z.string(),retiredAt:z.date().nullable(),slug:z.string()})),isPublic:z.boolean(),locale:z.string().nullable()}),`Delivery state of one ${name}`),400:invalidIdentifier,404:{description:`${name} not found`}}},handler:async c=>{const build=model.deliveryService;if(!build)throw notFound(definition);const id=identifier(c);const locale=c.req.query("locale");const delivery=build(c,{pluginId});const metadata=await delivery.findById(id,{locale});const history=await delivery.history(id,{locale});return c.json({canonicalPath:metadata?.canonicalPath??null,history:history.map(entry=>({createdAt:entry.createdAt,path:entry.path,retiredAt:entry.retiredAt,slug:entry.slug})),isPublic:metadata!==null,locale:metadata?.locale??null},200)}});const previewToken=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.view},route:{method:"post",path:"/{id}/preview",description:`Create a preview link for one ${name}`,request:{params:schemas.params},responses:{200:jsonResponse(z.object({expiresAt:z.date(),revisionId:z.number(),token:z.string(),url:z.url(),version:z.number()}),"Preview link created"),400:invalidIdentifier,404:{description:`${name} not found`},503:{description:"This deployment has no usable web or API origin, so no link can be built"}}},handler:async c=>{assertPreviewIsServable();const id=identifier(c);const row=await model.service(c).findById(id);if(!row)throw notFound(definition);const latest=await editorialService(c).revisions.latest(id);const version=row.version;const target=await resolveContentPreviewTarget(c,model,{id,row});const translationRevisionId=target.locale!==undefined&&model.translationEditorialService?(await model.translationEditorialService(c,{pluginId}).listRevisions(id,target.locale,{limit:1})).edges[0]?.id??0:undefined;const{expiresAt,token}=createContentPreviewToken({definition,itemId:id,languageId:target.languageId,locale:target.locale,pluginId,revisionId:latest?.id??0,secret:await previewSecret(c),translationRevisionId,version:latest?.version??(typeof version==="number"?version:1)});return c.json({expiresAt,revisionId:latest?.id??0,token,url:previewUrl(token,target),version:latest?.version??(typeof version==="number"?version:1)},200)}});const zodSchedule=z.object({action:z.enum(CONTENT_SCHEDULE_ACTIONS),actorName:z.string().nullable(),completedAt:z.union([z.date(),z.string()]).nullable(),createdAt:z.union([z.date(),z.string()]),createdBy:z.number().nullable(),effectsError:z.string().nullable(),id:z.number(),lastError:z.string().nullable(),scheduledFor:z.union([z.date(),z.string()]),status:z.enum(CONTENT_SCHEDULE_STATUSES)});const schedulesModel=c=>{const schedules=editorialService(c).schedules;if(!schedules){throw new HTTPException(500,{message:"This content type has no scheduling."})}return schedules};const scheduleList=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.view},route:{method:"get",path:"/{id}/schedules",description:`Pending and recent schedules for one ${name}`,request:{params:schemas.params},responses:{200:jsonResponse(z.object({edges:z.array(zodSchedule),hasCronAdapter:z.boolean()}),"Pending schedules first, then the most recent settled ones"),400:invalidIdentifier}},handler:async c=>{const edges=await schedulesModel(c).listForItem(identifier(c));return c.json({edges,hasCronAdapter:c.get("core")?.hasCronAdapter??false},200)}});const scheduleCreate=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.publish},route:{method:"post",path:"/{id}/schedule",description:`Schedule a ${name} to publish or unpublish later`,request:{params:schemas.params,body:jsonBody(z.strictObject({action:z.enum(CONTENT_SCHEDULE_ACTIONS),scheduledFor:z.iso.datetime()}))},responses:{200:jsonResponse(z.object({generation:z.number(),id:z.number(),scheduledFor:z.union([z.date(),z.string()])}),"Scheduled"),400:jsonResponse(zodContentScheduleRejection,"That time will not work"),404:{description:`${name} not found`}}},handler:async c=>{const id=identifier(c);const{action,scheduledFor}=await readJson(c,z.strictObject({action:z.enum(CONTENT_SCHEDULE_ACTIONS),scheduledFor:z.iso.datetime()}));const row=await model.service(c).findById(id);if(!row)throw notFound(definition);const actor=resolveContentActor(c);const result=await withHttpErrors("update",async()=>await schedulesModel(c).schedule({action,actorUserId:actor.userId,itemId:id,scheduledFor:new Date(scheduledFor)}),{contentTypeId:definition.id,itemId:id,structured:true});await emitContentEvent(c,definition,"scheduled",{action,actorUserId:actor.userId,contentId:id,scheduledFor:result.scheduledFor,scheduleId:result.id},{pluginId});return c.json(result,200)}});const scheduleCancel=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.publish},route:{method:"post",path:"/{id}/schedule/{scheduleId}/cancel",description:`Cancel a pending schedule for one ${name}`,request:{params:z.object({id:z.coerce.number(),scheduleId:z.coerce.number()})},responses:{200:jsonResponse(z.object({cancelled:z.boolean()}),"Cancelled"),400:invalidIdentifier,404:{description:"Schedule not found"}}},handler:async c=>{const id=identifier(c);const scheduleId=Number(c.req.param("scheduleId"));if(!Number.isInteger(scheduleId)||scheduleId<=0){throw new HTTPException(400,{message:"Invalid schedule identifier."})}const cancelled=await schedulesModel(c).cancel(id,scheduleId);if(!cancelled){throw new HTTPException(404,{message:"Schedule not found."})}const actor=resolveContentActor(c);await emitContentEvent(c,definition,"schedule_cancelled",{action:cancelled.action,actorUserId:actor.userId,contentId:id,scheduleId},{pluginId});return c.json({cancelled:true},200)}});const deleteEnvelope=z.strictObject({expectedVersion:z.number().int().positive()});const editorialRemove=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.delete},route:{method:"delete",path:"/{id}",description:`Delete a ${name}`,request:{params:schemas.params,body:jsonBody(deleteEnvelope)},responses:{200:jsonResponse(schemas.selectObject,`${name} deleted successfully`),400:invalidIdentifier,404:{description:`${name} not found`},409:jsonResponse(zodContentConflict,"Still referenced by other content, or the version moved")}},handler:async c=>{const id=identifier(c);const{expectedVersion}=await readJson(c,deleteEnvelope);const result=await withHttpErrors("delete",async()=>await editorialService(c).delete(id,{actor:resolveContentActor(c),expectedVersion}),{contentTypeId:definition.id,itemId:id,structured:true});if(!result)throw notFound(definition);await contentEditorialEffects(c,definition,result,{model,pluginId});return c.json(result.row,200)}});const remove=buildRoute({pluginId,adminStaffPermission:{module,permission:CONTENT_PERMISSIONS.delete},route:{method:"delete",path:"/{id}",description:`Delete a ${name}`,request:{params:schemas.params},responses:{200:jsonResponse(schemas.selectObject,`${name} deleted successfully`),400:invalidIdentifier,404:{description:`${name} not found`},409:{description:"Still referenced by other content"}}},handler:async c=>{const id=identifier(c);const row=await withHttpErrors("delete",async()=>model.service(c).delete(id));if(!row)throw notFound(definition);await emitContentEvent(c,definition,"deleted",{contentId:row.id},{pluginId});await syncContentSearch(c,definition,{operation:"delete",pluginId,row});return c.json(row,200)}});return[list,options,detail,create,editorial?editorialUpdate:update,editorial?editorialRemove:remove,...definition.publication.enabled?[publicationRoute("publish"),publicationRoute("unpublish")]:[],...editorial?[revisionList,revisionDetail,restore]:[],...hasFileFields?[upload]:[],...previewEnabled?[previewToken]:[],...definition.delivery.enabled?[deliveryDetail]:[],...definition.editorial.scheduling.enabled?[scheduleList,scheduleCreate,scheduleCancel]:[],...definition.localization.enabled?[...buildContentTranslationRoutes(model,{pluginId}),...buildContentLocalizedAdminRoutes(model,{pluginId})]:[]]};

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

@@ -0,0 +1,26 @@
+import type { Context } from "hono";
+import { z } from "zod";
+export declare const contentScheduleEffectsPayloadSchema: z.ZodObject<{
+    changedFields: z.ZodArray<z.ZodString>;
+    contentTypeId: z.ZodString;
+    itemId: z.ZodNumber;
+    operation: z.ZodEnum<{
+        publish: "publish";
+        unpublish: "unpublish";
+    }>;
+    pluginId: z.ZodString;
+    previousSlug: z.ZodNullable<z.ZodString>;
+    revisionId: z.ZodNullable<z.ZodNumber>;
+    row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    scheduleId: z.ZodNumber;
+    scheduledBy: z.ZodNullable<z.ZodNumber>;
+    version: z.ZodNumber;
+    wasPublic: z.ZodBoolean;
+}, z.core.$strip>;
+export type ContentScheduleEffectsPayload = z.infer<typeof contentScheduleEffectsPayloadSchema>;
+export interface ContentScheduleEffectsOutcome {
+    error?: string;
+    status: "delivered" | "unregistered";
+}
+export declare const runContentScheduleEffects: (c: Context, payload: ContentScheduleEffectsPayload) => Promise<ContentScheduleEffectsOutcome>;
+//# sourceMappingURL=schedule-effects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-effects.d.ts","sourceRoot":"","sources":["../../../../src/content/server/schedule-effects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgExB,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;iBAe9C,CAAC;AAEH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAC;AAkCF,MAAM,WAAW,6BAA6B;IAE5C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,GAAG,cAAc,CAAC;CACtC;AA2BD,eAAO,MAAM,yBAAyB,GACpC,GAAG,OAAO,EACV,SAAS,6BAA6B,KACrC,OAAO,CAAC,6BAA6B,CAsJvC,CAAC"}

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

@@ -0,0 +1 @@
+import{z}from"zod";import{contentLocaleInvalidations,diffContentPublicLocaleStates}from"../cache.js";import{CONTENT_SCHEDULE_ACTIONS}from"../const.js";import{contentEditorialEffects}from"./editorial-effects.js";import{contentDefinitionOf,findContentModel}from"./model.js";import{contentPublicLocaleStates}from"./public-locales.js";import{dispatchContentRevalidation}from"./revalidate-bridge.js";import{recordContentScheduleEffectsError}from"./schedules-model.js";import{isContentRowPublic}from"./search-document.js";const scheduledLocales=async(c,model,payload,row)=>{const after=await contentPublicLocaleStates(c,model,payload.itemId,{row});const before=await contentPublicLocaleStates(c,model,payload.itemId,{row:{...row,publishedAt:payload.wasPublic?row.publishedAt??new Date(0):null,status:payload.wasPublic?"published":"draft"}});return contentLocaleInvalidations({changed:"shared",defaultLocale:model.definition.localization.defaultLocale,fallback:model.definition.localization.fallback,states:diffContentPublicLocaleStates(before,after)})};export const contentScheduleEffectsPayloadSchema=z.object({changedFields:z.array(z.string()),contentTypeId:z.string().min(1),itemId:z.number().int().positive(),operation:z.enum(CONTENT_SCHEDULE_ACTIONS),pluginId:z.string().min(1),previousSlug:z.string().nullable(),revisionId:z.number().int().positive().nullable(),row:z.record(z.string(),z.unknown()),scheduleId:z.number().int().positive(),scheduledBy:z.number().int().nullable(),version:z.number().int().positive(),wasPublic:z.boolean()});const reviveDates=(definition,row)=>{const dateColumns=["createdAt","updatedAt",...definition.publication.enabled?["publishedAt"]:[],...Object.entries(definition.fields).filter(([,field])=>field.kind==="dateTime").map(([name])=>name)];const revived={...row};for(const name of dateColumns){const value=revived[name];if(typeof value!=="string")continue;const parsed=new Date(value);if(!Number.isNaN(parsed.getTime()))revived[name]=parsed}return revived};export const runContentScheduleEffects=async(c,payload)=>{const entry=findContentModel(c.get("core").contentModels,payload.contentTypeId);if(!entry){await recordContentScheduleEffectsError(c.get("db"),payload.scheduleId,`Content type "${payload.contentTypeId}" is no longer registered, so its scheduled ${payload.operation} was never announced.`);return{status:"unregistered"}}const definition=contentDefinitionOf(entry.model);const row=reviveDates(definition,payload.row);const outcome={changed:true,changedFields:payload.changedFields,operation:payload.operation,previousSlug:payload.previousSlug,restoredFromRevisionId:null,revisionId:payload.revisionId,row:row,version:payload.version};const{event,search,searchByLocale}=await contentEditorialEffects(c,definition,outcome,{model:entry.model,pluginId:payload.pluginId,scheduledBy:payload.scheduledBy,scheduleId:payload.scheduleId});const currentSlug=definition.publicApi.enabled?row[definition.publicApi.slugField]:undefined;const revalidation=await dispatchContentRevalidation(c,{contentTypeId:definition.id,...definition.delivery.enabled?{delivery:{sitemap:{contentChanged:true,indexChanged:true}}}:{},id:payload.itemId,isPublic:isContentRowPublic(row),...definition.localization.enabled&&definition.publicApi.enabled?{locales:await scheduledLocales(c,entry.model,payload,row)}:{},mode:"immediate",slugs:[...new Set([payload.previousSlug,currentSlug].filter(slug=>typeof slug==="string"&&slug!==""))],wasPublic:payload.wasPublic});const failures=[];if(event&&event.failures.length>0){failures.push(`event: ${event.failures.map(failure=>`${failure.pluginId}:${failure.module}:${failure.listener} (${failure.error})`).join(", ")}`)}if(search?.error)failures.push(`search: ${search.error.message}`);for(const outcome of searchByLocale??[]){if(outcome.error){failures.push(`search (${outcome.documentId}): ${outcome.error.message}`)}}if(revalidation.attempted>0&&revalidation.delivered<revalidation.attempted){failures.push(`cache: ${revalidation.delivered}/${revalidation.attempted} web origins accepted the invalidation`)}const error=failures.length>0?failures.join("; "):null;await recordContentScheduleEffectsError(c.get("db"),payload.scheduleId,error);if(error){throw new Error(`Scheduled ${payload.operation} of ${payload.contentTypeId}#${payload.itemId} committed, but its effects did not (${error}).`)}return{status:"delivered"}};

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

@@ -0,0 +1,59 @@
+import type { Context } from "hono";
+import type { ContentSchedule, ContentScheduleAction, ContentScheduleStatus } from "../schedules";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentDatabase } from "./service";
+export interface ClaimedContentSchedule {
+    action: ContentScheduleAction;
+    contentTypeId: string;
+    createdBy: null | number;
+    id: number;
+    itemId: number;
+    pluginId: string;
+}
+export declare const claimContentSchedule: (tx: ContentDatabase, { generation, now, scheduleId, }: {
+    generation: number;
+    now?: Date;
+    scheduleId: number;
+}) => Promise<ClaimedContentSchedule | null>;
+export declare const settleContentSchedule: (db: ContentDatabase, scheduleId: number, patch: {
+    expectedStatus?: ContentScheduleStatus;
+    lastError?: null | string;
+    status?: "cancelled" | "completed";
+}) => Promise<boolean>;
+export declare const recordContentScheduleEffectsError: (db: ContentDatabase, scheduleId: number, effectsError: null | string) => Promise<void>;
+export interface ContentSchedulesModel {
+    cancel: (itemId: number, scheduleId: number) => Promise<null | {
+        action: ContentScheduleAction;
+    }>;
+    listForItem: (itemId: number) => Promise<ContentSchedule[]>;
+    pendingForItem: (itemId: number, tx?: ContentDatabase) => Promise<{
+        action: ContentScheduleAction;
+        scheduledFor: Date;
+    }[]>;
+    recordError: (scheduleId: number, message: string) => Promise<void>;
+    schedule: (input: {
+        action: ContentScheduleAction;
+        actorUserId: null | number;
+        itemId: number;
+        now?: Date;
+        scheduledFor: Date;
+    }) => Promise<{
+        generation: number;
+        id: number;
+        scheduledFor: Date;
+    }>;
+}
+export declare const createContentSchedulesModel: ({ c, definition, pluginId, }: {
+    c: Context;
+    definition: AnyContentTypeDefinition;
+    pluginId: string;
+}) => ContentSchedulesModel;
+export declare const pruneContentSchedules: ({ db, knownContentTypeIds, olderThan, }: {
+    db: ContentDatabase;
+    knownContentTypeIds: string[];
+    olderThan: Date;
+}) => Promise<{
+    orphaned: number;
+    settled: number;
+}>;
+//# sourceMappingURL=schedules-model.d.ts.map

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

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

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

@@ -0,0 +1 @@
+import{and,desc,eq,inArray,lt,notInArray,sql}from"drizzle-orm";import{core_content_schedules}from"../../database/content.js";import{core_users}from"../../database/users.js";import{CONTENT_QUEUE_TASK_SCHEDULE,CONTENT_SCHEDULE_CODES}from"../const.js";import{ContentScheduleError}from"../errors.js";import{contentScheduleTimingError}from"../schedules.js";export const claimContentSchedule=async(tx,{generation,now=new Date,scheduleId})=>{const[row]=await tx.select({action:core_content_schedules.action,contentTypeId:core_content_schedules.contentTypeId,createdBy:core_content_schedules.createdBy,generation:core_content_schedules.generation,id:core_content_schedules.id,itemId:core_content_schedules.itemId,pluginId:core_content_schedules.pluginId,scheduledFor:core_content_schedules.scheduledFor,status:core_content_schedules.status}).from(core_content_schedules).where(eq(core_content_schedules.id,scheduleId)).limit(1).for("update");if(!row)return null;if(row.status!=="pending")return null;if(row.generation!==generation)return null;if(row.scheduledFor.getTime()>now.getTime())return null;return{action:row.action,contentTypeId:row.contentTypeId,createdBy:row.createdBy,id:row.id,itemId:row.itemId,pluginId:row.pluginId}};export const settleContentSchedule=async(db,scheduleId,patch)=>{const rows=await db.update(core_content_schedules).set({...patch.status?{status:patch.status}:{},...patch.status==="completed"?{completedAt:new Date}:{},...patch.lastError===undefined?{}:{lastError:patch.lastError}}).where(patch.expectedStatus===undefined?eq(core_content_schedules.id,scheduleId):and(eq(core_content_schedules.id,scheduleId),eq(core_content_schedules.status,patch.expectedStatus))).returning({id:core_content_schedules.id});return rows.length>0};export const recordContentScheduleEffectsError=async(db,scheduleId,effectsError)=>{await db.update(core_content_schedules).set({effectsError}).where(eq(core_content_schedules.id,scheduleId))};const HISTORY_LIMIT=10;export const createContentSchedulesModel=({c,definition,pluginId})=>{const contentTypeId=definition.id;const scope=itemId=>and(eq(core_content_schedules.pluginId,pluginId),eq(core_content_schedules.contentTypeId,contentTypeId),eq(core_content_schedules.itemId,itemId));const pendingForItem=async(itemId,tx)=>await (tx??c.get("db")).select({action:core_content_schedules.action,scheduledFor:core_content_schedules.scheduledFor}).from(core_content_schedules).where(and(scope(itemId),eq(core_content_schedules.status,"pending")));return{cancel:async(itemId,scheduleId)=>{const[row]=await c.get("db").update(core_content_schedules).set({status:"cancelled"}).where(and(scope(itemId),eq(core_content_schedules.id,scheduleId),eq(core_content_schedules.status,"pending"))).returning({action:core_content_schedules.action});return row??null},listForItem:async itemId=>{const rows=await c.get("db").select({action:core_content_schedules.action,actorName:core_users.name,completedAt:core_content_schedules.completedAt,createdAt:core_content_schedules.createdAt,createdBy:core_content_schedules.createdBy,effectsError:core_content_schedules.effectsError,id:core_content_schedules.id,lastError:core_content_schedules.lastError,scheduledFor:core_content_schedules.scheduledFor,status:core_content_schedules.status}).from(core_content_schedules).leftJoin(core_users,eq(core_users.id,core_content_schedules.createdBy)).where(scope(itemId)).orderBy(sql`case when ${core_content_schedules.status} = 'pending' then 0 else 1 end`,desc(core_content_schedules.scheduledFor)).limit(HISTORY_LIMIT);return rows},pendingForItem,schedule:async({action,actorUserId,itemId,now=new Date,scheduledFor})=>{if(!definition.editorial.scheduling.enabled){throw new ContentScheduleError(`This content type has no scheduling, so there is no "${action}" to schedule.`,{code:CONTENT_SCHEDULE_CODES.unsupported,contentTypeId})}return await c.get("db").transaction(async tx=>{const pending=await pendingForItem(itemId,tx);const timing=contentScheduleTimingError({action,now,pending:pending.filter(entry=>entry.action!==action),scheduledFor});if(timing){throw new ContentScheduleError(timing===CONTENT_SCHEDULE_CODES.order?"An unpublish has to be scheduled after the publish that is already pending.":"That time has already passed.",{code:timing,contentTypeId})}const[previous]=await tx.update(core_content_schedules).set({status:"cancelled"}).where(and(scope(itemId),eq(core_content_schedules.action,action),eq(core_content_schedules.status,"pending"))).returning({generation:core_content_schedules.generation});const generation=(previous?.generation??0)+1;const[row]=await tx.insert(core_content_schedules).values({action,contentTypeId,createdBy:actorUserId,generation,itemId,pluginId,scheduledFor}).returning({id:core_content_schedules.id});await c.get("queue").dispatch({availableAt:scheduledFor,name:CONTENT_QUEUE_TASK_SCHEDULE,payload:{generation,scheduleId:row.id},pluginId:"@vitnode/core",tx});return{generation,id:row.id,scheduledFor}})},recordError:async(scheduleId,message)=>{await c.get("db").update(core_content_schedules).set({lastError:message}).where(eq(core_content_schedules.id,scheduleId))}}};export const pruneContentSchedules=async({db,knownContentTypeIds,olderThan})=>{const settled=await db.delete(core_content_schedules).where(and(inArray(core_content_schedules.status,["cancelled","completed"]),lt(core_content_schedules.updatedAt,olderThan))).returning({id:core_content_schedules.id});const orphaned=await db.delete(core_content_schedules).where(knownContentTypeIds.length===0?sql`true`:notInArray(core_content_schedules.contentTypeId,knownContentTypeIds)).returning({id:core_content_schedules.id});return{orphaned:orphaned.length,settled:settled.length}};

package/dist/src/content/server/search-document.d.ts

@@ -0,0 +1,15 @@
+import type { SearchDocument } from "../../api/models/search";
+import type { AnyContentTypeDefinition } from "../types";
+export declare const isContentRowPublic: (row: object) => boolean;
+export declare const contentSearchDocument: (definition: AnyContentTypeDefinition, row: object, { locale, pluginId }?: {
+    locale?: string;
+    pluginId?: string;
+}) => null | SearchDocument;
+export declare const contentTranslationSearchDocument: (definition: AnyContentTypeDefinition, { base, locale, translation, }: {
+    base: object;
+    locale: string;
+    translation: object;
+}, { pluginId }?: {
+    pluginId?: string;
+}) => null | SearchDocument;
+//# sourceMappingURL=search-document.d.ts.map

package/dist/src/content/server/search-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-document.d.ts","sourceRoot":"","sources":["../../../../src/content/server/search-document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AA4EzD,eAAO,MAAM,kBAAkB,GAAI,KAAK,MAAM,KAAG,OAOhD,CAAC;AAwBF,eAAO,MAAM,qBAAqB,GAChC,YAAY,wBAAwB,EACpC,KAAK,MAAM,EACX,uBAAsB;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,KAChE,IAAI,GAAG,cAqET,CAAC;AAuBF,eAAO,MAAM,gCAAgC,GAC3C,YAAY,wBAAwB,EACpC,gCAIG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,EACxD,eAAc;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,KACvC,IAAI,GAAG,cAuCT,CAAC"}

package/dist/src/content/server/search-document.js

@@ -0,0 +1 @@
+import{isContentPubliclyVisible,isContentTranslationPubliclyVisible}from"../cache.js";import{partitionContentFields}from"../localization.js";import{readContentPath,splitContentFieldPath}from"../paths.js";import{contentSearchUrl}from"../search.js";const normalize=value=>typeof value==="string"?value.replace(/\s+/g," ").trim():"";const readSearchValue=(values,name)=>{const path=splitContentFieldPath(name);if(!path)return normalize(values[name]);const[owner,leaf]=path;const container=values[owner];if(Array.isArray(container)){return container.map(child=>normalize(child[leaf])).filter(value=>value!=="").join("\n")}return normalize(readContentPath(values,name))};const toDate=value=>{if(value instanceof Date)return value;if(typeof value!=="string")return undefined;const parsed=new Date(value);return Number.isNaN(parsed.getTime())?undefined:parsed};const toTimestamp=value=>{if(value instanceof Date||typeof value==="string")return value;return value===null?null:undefined};export const isContentRowPublic=row=>{const values=row;return isContentPubliclyVisible({publishedAt:toTimestamp(values.publishedAt),status:normalize(values.status)||undefined})};export const contentSearchDocument=(definition,row,{locale,pluginId}={})=>{const{publicApi,search}=definition;if(!search.enabled)return null;const values=row;const itemId=values.id;if(typeof itemId!=="number")return null;if(!isContentRowPublic(row))return null;const title=normalize(readSearchValue(values,search.titleField));if(title==="")return null;const url=contentSearchUrl(definition,normalize(values[publicApi.slugField]),locale);if(url===null)return null;const createdAt=toDate(values.publishedAt)??toDate(values.createdAt);if(!createdAt)return null;const sources=search.contentFields.includes(search.descriptionField??"")?search.contentFields:[...search.descriptionField?[search.descriptionField]:[],...search.contentFields];return{content:sources.map(name=>readSearchValue(values,name)).filter(value=>value!=="").join("\n\n"),createdAt,isPublic:true,itemId,itemType:definition.id,...pluginId===undefined?{}:{pluginId},...locale===undefined||locale===""?{}:{languageCode:locale},title,updatedAt:toDate(values.updatedAt),url}};export const contentTranslationSearchDocument=(definition,{base,locale,translation},{pluginId}={})=>{if(!definition.search.enabled||!definition.localization.enabled){return null}const baseValues=base;const translationValues=translation;if(!isContentTranslationPubliclyVisible({base:{publishedAt:toTimestamp(baseValues.publishedAt),status:normalize(baseValues.status)||undefined},translation:{publishedAt:toTimestamp(translationValues.publishedAt),status:normalize(translationValues.status)||undefined}})){return null}const{localizedFields}=partitionContentFields(definition.fields);const merged={...baseValues};for(const name of Object.keys(localizedFields)){merged[name]=translationValues[name]}merged.publishedAt=translationValues.publishedAt??baseValues.publishedAt;merged.updatedAt=translationValues.updatedAt??baseValues.updatedAt;return contentSearchDocument(definition,merged,{locale,pluginId})};

package/dist/src/content/server/search-indexer.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from "hono";
+import type { SearchIndexer, SearchIndexerPage } from "../../api/models/search";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentModel } from "./model";
+export interface ContentSearchIndexer extends SearchIndexer {
+    load: (c: Context, offset: number, limit: number) => Promise<SearchIndexerPage>;
+}
+export declare const createContentSearchIndexer: <TDefinition extends AnyContentTypeDefinition>(model: ContentModel<TDefinition>, { pluginId }: {
+    pluginId: string;
+}) => ContentSearchIndexer;
+export declare const createContentLocalizedSearchIndexer: <TDefinition extends AnyContentTypeDefinition>(model: ContentModel<TDefinition>, { pluginId }: {
+    pluginId: string;
+}) => ContentSearchIndexer;
+//# sourceMappingURL=search-indexer.d.ts.map

package/dist/src/content/server/search-indexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-indexer.d.ts","sourceRoot":"","sources":["../../../../src/content/server/search-indexer.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAIpC,OAAO,KAAK,EAEV,aAAa,EACb,iBAAiB,EAClB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,wBAAwB,EAAmB,MAAM,UAAU,CAAC;AAE1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAoJ5C,MAAM,WAAW,oBAAqB,SAAQ,aAAa;IACzD,IAAI,EAAE,CACJ,CAAC,EAAE,OAAO,EACV,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,KACV,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACjC;AAqBD,eAAO,MAAM,0BAA0B,GACrC,WAAW,SAAS,wBAAwB,EAE5C,OAAO,YAAY,CAAC,WAAW,CAAC,EAChC,cAAc;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,KACjC,oBAsHF,CAAC;AAwBF,eAAO,MAAM,mCAAmC,GAC9C,WAAW,SAAS,wBAAwB,EAE5C,OAAO,YAAY,CAAC,WAAW,CAAC,EAChC,cAAc;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,KACjC,oBA2KF,CAAC"}

package/dist/src/content/server/search-indexer.js

@@ -0,0 +1 @@
+import{and,asc,count,eq,gt,or}from"drizzle-orm";import{ContentEngineError}from"../errors.js";import{partitionContentFields}from"../localization.js";import{contentColumnsToValues,contentLeafColumnName,splitContentFieldPath}from"../paths.js";import{contentSearchIndexedFieldNames}from"../search.js";import{listContentLanguages}from"./language-resolver.js";import{contentTranslationPublicationColumns,publicationColumns,publishedCondition}from"./publication.js";import{contentSearchDocument,contentTranslationSearchDocument}from"./search-document.js";const REQUIRED_COLUMNS=["id","createdAt","updatedAt","status","publishedAt"];const resolveSearchSources=definition=>{const{localizedFields,sharedFields}=partitionContentFields(definition.fields);const sources={collections:[],localizedColumns:[],localizedGroups:{},sharedColumns:[],sharedGroups:{}};for(const name of contentSearchIndexedFieldNames(definition)){const path=splitContentFieldPath(name);if(!path){if(localizedFields[name]!==undefined){sources.localizedColumns.push(name);continue}if(sharedFields[name]!==undefined)sources.sharedColumns.push(name);continue}const[owner,leaf]=path;const container=definition.fields[owner];if(!container)continue;if(container.kind!=="group"){if(!sources.collections.includes(owner))sources.collections.push(owner);continue}const column=contentLeafColumnName(owner,leaf);if(localizedFields[owner]!==undefined){sources.localizedColumns.push(column);sources.localizedGroups[owner]=container;continue}sources.sharedColumns.push(column);sources.sharedGroups[owner]=container}return sources};const loadSearchCollections=async({advanced,c,itemIds,wanted})=>{if(wanted.length===0)return new Map;const unique=[...new Set(itemIds.filter(id=>Number.isInteger(id)))];if(unique.length===0)return new Map;return await advanced.loadMany(unique,c.get("db"),wanted)};export const createContentSearchIndexer=(model,{pluginId})=>{const{definition}=model;const table=model.table;const columns=model.columns;const published=publicationColumns(definition,columns);const primaryCursor=columns.id;const sources=resolveSearchSources(definition);const advanced=model.advanced;const selection=Object.fromEntries([...new Set([...REQUIRED_COLUMNS,...sources.sharedColumns])].map(name=>[name,columns[name]]));const cursors=new WeakMap;return{itemType:definition.id,count:async c=>{const[row]=await c.get("db").select({value:count()}).from(table).where(publishedCondition(published));return row?.value??0},load:async(c,offset,limit)=>{if(offset===0)cursors.delete(c);const cursor=cursors.get(c);const rows=await c.get("db").select(selection).from(table).where(cursor===undefined?publishedCondition(published):and(publishedCondition(published),gt(primaryCursor,cursor))).orderBy(asc(primaryCursor)).limit(limit);const last=rows.at(-1);if(last&&typeof last.id==="number")cursors.set(c,last.id);const collections=await loadSearchCollections({advanced,c,itemIds:rows.map(row=>Number(row.id)),wanted:sources.collections});const documents=rows.flatMap(row=>{const values=row;const document=contentSearchDocument(definition,{...values,...contentColumnsToValues(sources.sharedGroups,values),...collections.get(Number(values.id))},{pluginId});return document?[document]:[]});return{documents,itemsRead:rows.length}}}};export const createContentLocalizedSearchIndexer=(model,{pluginId})=>{const{definition}=model;const table=model.table;const translationTable=model.translationTable;const columns=model.columns;const translationColumns=model.translationColumns;if(!translationTable||!translationColumns){throw new ContentEngineError("The localized search indexer needs `localization: { enabled: true, defaultLocale }` on the content type.",{contentTypeId:definition.id})}const rows=translationColumns;const base=publicationColumns(definition,columns);const translation=contentTranslationPublicationColumns(definition,translationColumns);const sources=resolveSearchSources(definition);const advanced=model.advanced;const sharedSelection=[...new Set([...REQUIRED_COLUMNS,...sources.sharedColumns])];const localizedSelection=[...new Set(sources.localizedColumns)];const visible=()=>and(publishedCondition(base),publishedCondition(translation));const cursors=new WeakMap;return{itemType:definition.id,count:async c=>{const[row]=await c.get("db").select({value:count()}).from(translationTable).innerJoin(table,eq(rows.itemId,columns.id)).where(visible());return row?.value??0},load:async(c,offset,limit)=>{if(offset===0)cursors.delete(c);const cursor=cursors.get(c);const page=await c.get("db").select({...Object.fromEntries(sharedSelection.map(name=>[name,columns[name]])),_languageId:rows.languageId,_publishedAt:rows.publishedAt,_status:rows.status,_updatedAt:rows.updatedAt,...Object.fromEntries(localizedSelection.map(name=>[`t_${name}`,rows[name]]))}).from(translationTable).innerJoin(table,eq(rows.itemId,columns.id)).where(cursor===undefined?visible():and(visible(),or(gt(columns.id,cursor.itemId),and(eq(columns.id,cursor.itemId),gt(rows.languageId,cursor.languageId))))).orderBy(asc(columns.id),asc(rows.languageId)).limit(limit);const last=page.at(-1);if(last){cursors.set(c,{itemId:last.id,languageId:last._languageId})}const languages=await listContentLanguages(c);const localeOf=new Map(languages.map(language=>[language.id,language.locale]));const collections=await loadSearchCollections({advanced,c,itemIds:page.map(row=>Number(row.id)),wanted:sources.collections});const documents=page.flatMap(row=>{const values=row;const locale=localeOf.get(values._languageId);if(locale===undefined)return[];const translationColumnValues=Object.fromEntries(localizedSelection.map(name=>[name,values[`t_${name}`]]));const document=contentTranslationSearchDocument(definition,{base:{...values,...contentColumnsToValues(sources.sharedGroups,values),...collections.get(Number(values.id))},locale,translation:{publishedAt:values._publishedAt,status:values._status,updatedAt:values._updatedAt,...translationColumnValues,...contentColumnsToValues(sources.localizedGroups,translationColumnValues)}},{pluginId});return document?[document]:[]});return{documents,itemsRead:page.length}}}};

package/dist/src/content/server/search-sync.d.ts

@@ -0,0 +1,30 @@
+import type { Context } from "hono";
+import type { AnyContentTypeDefinition } from "../types";
+import type { AnyContentModel } from "./model";
+export type ContentSearchOperation = "create" | "delete" | "publish" | "restore" | "unpublish" | "update";
+export interface ContentSearchSyncInput {
+    advanced?: Record<string, unknown>;
+    changed?: boolean;
+    changedFields?: readonly string[];
+    operation: ContentSearchOperation;
+    pluginId?: string;
+    row: object;
+}
+export interface ContentSearchSyncOutcome {
+    action: "delete" | "skip" | "upsert";
+    documentId: string;
+    error?: Error;
+}
+export declare const syncContentSearch: (c: Context, definition: AnyContentTypeDefinition, input: ContentSearchSyncInput) => Promise<ContentSearchSyncOutcome>;
+export interface ContentLocalizedSearchSyncInput {
+    advanced?: Record<string, unknown>;
+    changed?: boolean;
+    changedFields?: readonly string[];
+    locale?: string;
+    operation: ContentSearchOperation;
+    pluginId?: string;
+    row: object;
+}
+export declare const syncContentLocalizedSearch: (c: Context, model: AnyContentModel, input: ContentLocalizedSearchSyncInput) => Promise<ContentSearchSyncOutcome[]>;
+export declare const contentSearchAdvancedValues: (c: Context, model: AnyContentModel, itemId: number) => Promise<Record<string, unknown> | undefined>;
+//# sourceMappingURL=search-sync.d.ts.map

package/dist/src/content/server/search-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-sync.d.ts","sourceRoot":"","sources":["../../../../src/content/server/search-sync.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,eAAe,EAAE,MAAM,SAAS,CAAC;AAkB/C,MAAM,MAAM,sBAAsB,GAChC,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;AAEvE,MAAM,WAAW,sBAAsB;IASrC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAMnC,OAAO,CAAC,EAAE,OAAO,CAAC;IAKlB,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,SAAS,EAAE,sBAAsB,CAAC;IAMlC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,QAAQ,GAAG,MAAM,GAAG,QAAQ,CAAC;IAErC,UAAU,EAAE,MAAM,CAAC;IAEnB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AA0ED,eAAO,MAAM,iBAAiB,GAC5B,GAAG,OAAO,EACV,YAAY,wBAAwB,EACpC,OAAO,sBAAsB,KAC5B,OAAO,CAAC,wBAAwB,CAiElC,CAAC;AAEF,MAAM,WAAW,+BAA+B;IAY9C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAKnC,OAAO,CAAC,EAAE,OAAO,CAAC;IAKlB,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAWlC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,sBAAsB,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,GAAG,EAAE,MAAM,CAAC;CACb;AA+DD,eAAO,MAAM,0BAA0B,GACrC,GAAG,OAAO,EACV,OAAO,eAAe,EACtB,OAAO,+BAA+B,KACrC,OAAO,CAAC,wBAAwB,EAAE,CA+GpC,CAAC;AAaF,eAAO,MAAM,2BAA2B,GACtC,GAAG,OAAO,EACV,OAAO,eAAe,EACtB,QAAQ,MAAM,KACb,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAK7C,CAAC"}

package/dist/src/content/server/search-sync.js

@@ -0,0 +1 @@
+import{eq}from"drizzle-orm";import{partitionContentFields}from"../localization.js";import{contentColumnsToValues,contentStorageColumns}from"../paths.js";import{contentSearchDocumentId,contentSearchIndexedCollections,contentSearchIndexedPaths}from"../search.js";import{listContentLanguages}from"./language-resolver.js";import{contentDefinitionOf}from"./model.js";import{contentSearchDocument,contentTranslationSearchDocument,isContentRowPublic}from"./search-document.js";const decide=(definition,{changed,changedFields,operation,row},isPublic)=>{const values=row;if(operation==="delete"){return values.publishedAt===null||values.publishedAt===undefined?"skip":"delete"}if(operation==="unpublish")return changed===true?"delete":"skip";if(operation==="publish"){return changed===true&&isPublic?"upsert":"skip"}if(operation==="create")return isPublic?"upsert":"skip";if(!isPublic)return"skip";const indexed=contentSearchIndexedPaths(definition);return(changedFields??[]).some(name=>indexed.has(name))?"upsert":"skip"};export const syncContentSearch=async(c,definition,input)=>{const values=input.row;const itemId=typeof values.id==="number"?values.id:0;const documentId=contentSearchDocumentId(definition,itemId);if(!definition.search.enabled||itemId===0){return{action:"skip",documentId}}const decided=decide(definition,input,isContentRowPublic(input.row));if(decided==="skip")return{action:decided,documentId};const document=decided==="upsert"?contentSearchDocument(definition,{...input.row,...input.advanced},{pluginId:input.pluginId}):null;const action=decided==="upsert"&&!document?"delete":decided;try{if(document){await c.get("search").index(document)}else{await c.get("search").delete(definition.id,itemId)}return{action,documentId}}catch(err){const error=err instanceof Error?err:new Error(String(err));const message=`[content-search] ${JSON.stringify({action,contentTypeId:definition.id,documentId,error:error.message,itemId,itemType:definition.id,operation:input.operation,pluginId:input.pluginId})}`;try{await c.get("log").error(message)}catch{console.error(`[VitNode] Failed to log content search failure: ${message}`)}return{action,documentId,error}}};const readTranslations=async(c,model,itemId)=>{const columns=model.translationColumns;const table=model.translationTable;if(!columns||!table)return[];const{localizedFields}=partitionContentFields(contentDefinitionOf(model).fields);const storage=contentStorageColumns(localizedFields);const rows=await c.get("db").select({languageId:columns.languageId,publishedAt:columns.publishedAt,status:columns.status,updatedAt:columns.updatedAt,...Object.fromEntries(Object.keys(storage).map(name=>[name,columns[name]]))}).from(table).where(eq(columns.itemId,itemId));return rows.map(row=>({languageId:row.languageId,values:{...row,...contentColumnsToValues(localizedFields,row)}}))};export const syncContentLocalizedSearch=async(c,model,input)=>{const definition=contentDefinitionOf(model);const values=input.row;const itemId=typeof values.id==="number"?values.id:0;if(!definition.search.enabled||!definition.localization.enabled||itemId===0){return[]}if(input.operation==="delete"){const locale=input.locale?.trim();const scoped=locale===undefined||locale===""?undefined:locale;return[await write(c,definition,{documentId:contentSearchDocumentId(definition,itemId,scoped),run:async()=>{await c.get("search").delete(definition.id,itemId,scoped)},action:"delete",input,itemId})]}if((input.operation==="publish"||input.operation==="unpublish")&&input.changed!==true){return[]}if(input.operation==="update"||input.operation==="restore"){const indexed=contentSearchIndexedPaths(definition);const moved=(input.changedFields??[]).some(name=>indexed.has(name));if(!moved)return[]}const languages=await listContentLanguages(c);const localeOf=new Map(languages.map(language=>[language.id,language.locale]));const translations=await readTranslations(c,model,itemId);const wanted=input.locale?.trim().toLowerCase();const outcomes=[];for(const translation of translations){const locale=localeOf.get(translation.languageId);if(locale===undefined)continue;if(wanted!==undefined&&locale.toLowerCase()!==wanted)continue;const document=contentTranslationSearchDocument(definition,{base:{...input.row,...input.advanced},locale,translation:translation.values},{pluginId:input.pluginId});outcomes.push(await write(c,definition,{action:document?"upsert":"delete",documentId:contentSearchDocumentId(definition,itemId,locale),input,itemId,run:async()=>{if(document){await c.get("search").index(document);return}await c.get("search").delete(definition.id,itemId,locale)}}))}return outcomes};export const contentSearchAdvancedValues=async(c,model,itemId)=>{const wanted=contentSearchIndexedCollections(contentDefinitionOf(model));if(wanted.length===0||itemId===0)return undefined;return await model.service(c).advancedFields(itemId,wanted)};const write=async(c,definition,{action,documentId,input,itemId,run})=>{try{await run();return{action,documentId}}catch(err){const error=err instanceof Error?err:new Error(String(err));const message=`[content-search] ${JSON.stringify({action,contentTypeId:definition.id,documentId,error:error.message,itemId,itemType:definition.id,operation:input.operation,pluginId:input.pluginId})}`;try{await c.get("log").error(message)}catch{console.error(`[VitNode] Failed to log content search failure: ${message}`)}return{action,documentId,error}}};

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

@@ -0,0 +1,102 @@
+import type { SQL } from "drizzle-orm";
+import type { PgColumn, PgTableWithColumns, TableConfig } from "drizzle-orm/pg-core";
+import type { Context } from "hono";
+import type { ContentSchemas } from "../schemas";
+import type { AnyContentTypeDefinition, ContentAdvancedValues, ContentChangedPath, ContentCreateInput, ContentDetail, ContentFilterInput, ContentInnerFieldsOf, ContentOrderableFieldName, ContentReferenceFieldName, ContentRelationCollectionName, ContentRepeatableFieldName, ContentRepeatableInputRow, ContentRepeatableRow, ContentSelect, ContentUpdateInput, ContentValuesOf } from "../types";
+import type { ContentAdvancedStore } from "./advanced-store";
+export type ContentLabels = Record<string, null | string>;
+export type ContentListRow<TDefinition> = ContentSelect<TDefinition> & {
+    labels: ContentLabels;
+};
+export interface ContentPageInfo {
+    count: number;
+    endCursor: null | string;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor: null | string;
+    totalCount: number;
+}
+export interface ContentFindManyArgs<TDefinition> {
+    filters?: ContentFilterInput<TDefinition>;
+    orderBy?: {
+        column?: ContentOrderableFieldName<TDefinition>;
+        order?: "asc" | "desc";
+    };
+    query?: {
+        cursor?: string;
+        first?: string;
+        last?: string;
+        search?: string;
+    };
+    where?: SQL;
+}
+export type ContentDatabase = Omit<Context["var"]["db"], "$client">;
+export interface ContentServiceOptions {
+    tx?: ContentDatabase;
+}
+export interface ContentUpdateResult<TDefinition> {
+    changedFields: ContentChangedPath<TDefinition>[];
+    row: ContentSelect<TDefinition>;
+}
+export interface ContentRelationMethods<TDefinition> {
+    add: (itemId: number, relatedItemId: number, options?: ContentWriteOptions) => Promise<ContentUpdateResult<TDefinition> | null>;
+    get: (itemId: number, options?: ContentServiceOptions) => Promise<number[]>;
+    remove: (itemId: number, relatedItemId: number, options?: ContentWriteOptions) => Promise<ContentUpdateResult<TDefinition> | null>;
+    reorder: (itemId: number, relatedItemIds: readonly number[], options?: ContentWriteOptions) => Promise<ContentUpdateResult<TDefinition> | null>;
+    set: (itemId: number, relatedItemIds: readonly number[], options?: ContentWriteOptions) => Promise<ContentUpdateResult<TDefinition> | null>;
+}
+export interface ContentRepeatableMethods<TDefinition, TName> {
+    create: (itemId: number, values: ContentValuesOf<ContentInnerFieldsOf<TDefinition, TName>>, options?: ContentWriteOptions) => Promise<ContentUpdateResult<TDefinition> | null>;
+    delete: (itemId: number, childId: number, options?: ContentWriteOptions) => Promise<ContentUpdateResult<TDefinition> | null>;
+    list: (itemId: number, options?: ContentServiceOptions) => Promise<ContentRepeatableRow<ContentInnerFieldsOf<TDefinition, TName>>[]>;
+    reorder: (itemId: number, childIds: readonly number[], options?: ContentWriteOptions) => Promise<ContentUpdateResult<TDefinition> | null>;
+    set: (itemId: number, rows: readonly ContentRepeatableInputRow<ContentInnerFieldsOf<TDefinition, TName>>[], options?: ContentWriteOptions) => Promise<ContentUpdateResult<TDefinition> | null>;
+    update: (itemId: number, childId: number, values: Partial<ContentValuesOf<ContentInnerFieldsOf<TDefinition, TName>>>, options?: ContentWriteOptions) => Promise<ContentUpdateResult<TDefinition> | null>;
+}
+export type ContentWriteOptions = ContentServiceOptions;
+export interface ContentPublicationResult<TDefinition> {
+    changed: boolean;
+    publishedAt: Date | null;
+    row: ContentSelect<TDefinition>;
+}
+export interface ContentPublicationMethods<TDefinition> {
+    publish: (id: number, options?: ContentServiceOptions) => Promise<ContentPublicationResult<TDefinition> | null>;
+    unpublish: (id: number, options?: ContentServiceOptions) => Promise<ContentPublicationResult<TDefinition> | null>;
+}
+export type ContentService<TDefinition> = ContentServiceBase<TDefinition> & (TDefinition extends {
+    publication: {
+        enabled: true;
+    };
+} ? ContentPublicationMethods<TDefinition> : Partial<Record<keyof ContentPublicationMethods<TDefinition>, never>>);
+export interface ContentServiceBase<TDefinition> {
+    advanced: (id: number, options?: ContentServiceOptions) => Promise<ContentAdvancedValues<TDefinition>>;
+    advancedFields: (id: number, fields: readonly string[], options?: ContentServiceOptions) => Promise<Record<string, unknown>>;
+    create: (values: ContentCreateInput<TDefinition>, options?: ContentServiceOptions) => Promise<ContentSelect<TDefinition>>;
+    delete: (id: number, options?: ContentServiceOptions) => Promise<ContentSelect<TDefinition> | null>;
+    findById: (id: number, options?: ContentServiceOptions) => Promise<ContentSelect<TDefinition> | null>;
+    findDetail: (id: number, options?: ContentServiceOptions) => Promise<ContentDetail<TDefinition> | null>;
+    findMany: (args?: ContentFindManyArgs<TDefinition>) => Promise<{
+        edges: ContentListRow<TDefinition>[];
+        pageInfo: ContentPageInfo;
+    }>;
+    findRowById: (id: number, options?: ContentServiceOptions) => Promise<ContentListRow<TDefinition> | null>;
+    options: (field: ContentReferenceFieldName<TDefinition>, search?: string, ids?: readonly number[]) => Promise<{
+        color?: string;
+        label: string;
+        value: number;
+    }[]>;
+    relations: Record<ContentRelationCollectionName<TDefinition>, ContentRelationMethods<TDefinition>>;
+    repeatable: {
+        [K in ContentRepeatableFieldName<TDefinition>]: ContentRepeatableMethods<TDefinition, K>;
+    };
+    update: (id: number, values: ContentUpdateInput<TDefinition>, options?: ContentServiceOptions) => Promise<ContentUpdateResult<TDefinition> | null>;
+}
+export declare const createContentService: <TDefinition extends AnyContentTypeDefinition>({ advanced, c, columns, definition, schemas, table, }: {
+    advanced?: ContentAdvancedStore;
+    c: Context;
+    columns: Record<string, PgColumn>;
+    definition: TDefinition;
+    schemas: ContentSchemas<TDefinition>;
+    table: PgTableWithColumns<TableConfig>;
+}) => ContentService<TDefinition>;
+//# sourceMappingURL=service.d.ts.map

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

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

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

@@ -0,0 +1 @@
+import{and,eq,inArray,ne,sql}from"drizzle-orm";import{withPagination}from"../../api/lib/with-pagination.js";import{CONTENT_DEFAULT_PAGE_SIZE,CONTENT_EDITORIAL_FIELDS,CONTENT_OPTIONS_LIMIT,CONTENT_PUBLICATION_FIELDS,CONTENT_SYSTEM_FIELDS}from"../const.js";import{ContentEngineError}from"../errors.js";import{partitionContentFields}from"../localization.js";import{contentColumnsToValues,contentStorageColumns}from"../paths.js";import{orderableColumns}from"../registry.js";import{buildContentRelationOperations,buildContentRepeatableOperations,contentCollectionKinds}from"./collection-api.js";import{assertContentFileReferences}from"./files.js";import{findContentLanguage}from"./language-resolver.js";import{buildFilterCondition,buildOrderColumn,buildSearchCondition,changedPathsToColumns,diffChangedPaths,toInsertColumns}from"./query.js";import{LABEL_PREFIX,resolveCollectionPickerTargets,resolveReferenceTargets,toLabel}from"./references.js";import{createSlugNormalizer}from"./slugs.js";export const createContentService=({advanced,c,columns,definition,schemas,table})=>{const{collectionFields,sharedFields}=partitionContentFields(definition.fields);const fields=sharedFields;const storageColumns=contentStorageColumns(fields);const filterableFields={...fields,...collectionFields};const store=advanced;const contentTypeId=definition.id;const primaryCursor=columns.id;const orderable=orderableColumns(definition);const publication=definition.publication.enabled;const generatedColumnNames=[...CONTENT_SYSTEM_FIELDS,...publication?CONTENT_PUBLICATION_FIELDS:[],...definition.editorial.enabled?CONTENT_EDITORIAL_FIELDS:[]];const ownColumnNames=[...generatedColumnNames,...Object.keys(storageColumns)];const references=resolveReferenceTargets(definition,table,columns);const collectionReferences=resolveCollectionPickerTargets(definition,field=>store?.targetTable(field)??null);const localizedReferences=[...Object.entries(references),...Object.entries(collectionReferences)].filter(([,target])=>target.localizedLabel!==undefined);const searchColumns=definition.admin.list.searchableFields.map(name=>columns[name]);const{withCreateSlugs,withUpdateSlugs}=createSlugNormalizer(contentTypeId,fields);const mutableRelations={};const mutableRepeatables={};const db=options=>options?.tx??c.get("db");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 toRow=row=>projectRow(row);const splitLabels=row=>{const labels={};const values={};for(const[key,value]of Object.entries(row)){if(key.startsWith(LABEL_PREFIX)){labels[key.slice(LABEL_PREFIX.length)]=toLabel(value);continue}values[key]=value}return{...projectRow(values),labels}};const viewerLocale=()=>{const i18n=c.get("i18n");return i18n?.resolveLocale()};const labelLanguages=async()=>{const byDefaultLocale=new Map;if(localizedReferences.length===0){return{byDefaultLocale,viewer:null}}const locale=viewerLocale();const viewer=locale===undefined?null:await findContentLanguage(c,locale);for(const[,target]of localizedReferences){const defaultLocale=target.localizedLabel?.defaultLocale;if(defaultLocale===undefined||byDefaultLocale.has(defaultLocale)){continue}const language=await findContentLanguage(c,defaultLocale);byDefaultLocale.set(defaultLocale,language?.id??null)}return{byDefaultLocale,viewer:viewer?.id??null}};const labelSelection=(target,languages)=>{const plain={joins:[],label:target.labelColumn,searchColumns:[target.labelColumn]};const localized=target.localizedLabel;if(!localized)return plain;const fallbackId=languages.byDefaultLocale.get(localized.defaultLocale)??null;const wanted=[{languageId:languages.viewer,source:localized.viewer},...fallbackId!==null&&fallbackId!==languages.viewer?[{languageId:fallbackId,source:localized.fallback}]:[]].filter(entry=>entry.languageId!==null);if(wanted.length===0)return plain;return{joins:wanted.map(({languageId,source})=>({on:and(eq(source.itemColumn,target.idColumn),eq(source.languageColumn,languageId)),table:source.aliased})),label:sql`coalesce(${sql.join(wanted.map(({source})=>source.labelColumn),sql`, `)})`,searchColumns:wanted.map(({source})=>source.labelColumn)}};const referenceLabels=async()=>{const languages=await labelLanguages();return Object.fromEntries(Object.entries(references).map(([name,target])=>[name,labelSelection(target,languages)]))};const readOne=async(id,database)=>{const[row]=await database.select(ownSelection()).from(table).where(eq(primaryCursor,id)).limit(1);return row??null};const publishedAtOf=row=>{const value=row.publishedAt;return value instanceof Date?value:null};const transition=async(id,options,values,guard)=>{const database=db(options);const[row]=await database.update(table).set(values).where(and(eq(primaryCursor,id),guard)).returning(ownSelection());if(row)return{changed:true,publishedAt:publishedAtOf(row),row:toRow(row)};const current=await readOne(id,database);return current?{changed:false,publishedAt:publishedAtOf(current),row:toRow(current)}:null};const publicationMethods={publish:async(id,options)=>await transition(id,options,{publishedAt:sql`coalesce(${columns.publishedAt}, now())`,status:"published"},ne(columns.status,"published")),unpublish:async(id,options)=>await transition(id,options,{status:"draft"},eq(columns.status,"published"))};const transact=async(options,body)=>{if(options?.tx)return await body(options.tx);if(!store?.enabled)return await body(c.get("db"));return await c.get("db").transaction(async tx=>await body(tx))};const inTransaction=async(options,body)=>options?.tx?await body(options.tx):await c.get("db").transaction(async tx=>await body(tx));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 service={advanced:async(id,options)=>await store?.load(id,db(options))??{},advancedFields:async(id,wanted,options)=>await store?.load(id,db(options),wanted)??{},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)}return toRow(row)}),delete:async(id,options)=>{const[row]=await db(options).delete(table).where(eq(primaryCursor,id)).returning(ownSelection());return row?toRow(row):null},findById:async(id,options)=>{const row=await readOne(id,db(options));return row?toRow(row):null},findRowById:async(id,options)=>{const labels=await referenceLabels();const selection={...ownSelection(),...Object.fromEntries(Object.entries(labels).map(([name,entry])=>[`${LABEL_PREFIX}${name}`,entry.label]))};let builder=db(options).select(selection).from(table).$dynamic();for(const[name,target]of Object.entries(references)){builder=builder.leftJoin(target.aliased,eq(target.owner,target.idColumn));for(const join of labels[name].joins){builder=builder.leftJoin(join.table,join.on)}}const[row]=await builder.where(eq(primaryCursor,id)).limit(1);return row?splitLabels(row):null},findDetail:async(id,options)=>{const database=db(options);const row=await readOne(id,database);if(!row)return null;return{...toRow(row),...await store?.load(id,database)}},findMany:async({filters={},orderBy,query={},where}={})=>{const conditions=[where,buildFilterCondition({columns,contentTypeId,fields:filterableFields,filters:filters,membership:store?.membershipCondition,publication}),buildSearchCondition(searchColumns,query.search)].filter(item=>item!==undefined);const combined=conditions.length>1?and(...conditions):conditions[0];const labels=await referenceLabels();const data=await withPagination({c,params:{query:{...query,search:undefined}},primaryCursor,orderBy:{column:buildOrderColumn({columns,contentTypeId,fallback:definition.admin.list.defaultOrderBy,orderBy:orderBy?.column,orderable}),order:orderBy?.order??definition.admin.list.defaultOrder},table,where:combined,query:async({cursorSelection,limit,orderBy:order,where:rowWhere})=>{const selection={...ownSelection(),...Object.fromEntries(Object.entries(labels).map(([name,entry])=>[`${LABEL_PREFIX}${name}`,entry.label])),...cursorSelection};let builder=c.get("db").select(selection).from(table).$dynamic();for(const[name,target]of Object.entries(references)){builder=builder.leftJoin(target.aliased,eq(target.owner,target.idColumn));for(const join of labels[name].joins){builder=builder.leftJoin(join.table,join.on)}}return await builder.where(rowWhere).orderBy(order).limit(typeof limit==="number"?limit:CONTENT_DEFAULT_PAGE_SIZE)}});return{edges:data.edges.map(splitLabels),pageInfo:data.pageInfo}},options:async(fieldName,search,ids)=>{const target=references[fieldName]??collectionReferences[fieldName];if(!target){throw new ContentEngineError(`Field "${fieldName}" is not a relation or user field.`,{contentTypeId})}if(ids?.length===0)return[];const user=target.userColumns;const{joins,label,searchColumns:searchable}=labelSelection(target,await labelLanguages());let builder=c.get("db").select({label,value:target.idColumn,...user?{avatarColor:user.avatarColor,nameCode:user.nameCode}:{},...target.colorColumn?{color:target.colorColumn}:{}}).from(target.aliased).$dynamic();for(const join of joins){builder=builder.leftJoin(join.table,join.on)}const rows=await builder.where(ids?inArray(target.idColumn,[...ids]):buildSearchCondition(user?[...searchable,user.nameCode]:searchable,search)).orderBy(label).limit(ids?ids.length:CONTENT_OPTIONS_LIMIT);return rows.map(row=>{const value=Number(row.value);const entry=row;const color=target.colorColumn?toLabel(entry.color):null;return{label:toLabel(row.label)??String(value),value,...user?{avatarColor:toLabel(entry.avatarColor)??"",nameCode:toLabel(entry.nameCode)??""}:{},...color===null||color===""?{}:{color}}})},relations:mutableRelations,repeatable:mutableRepeatables,update:async(id,values,options)=>await transact(options,async tx=>{const patch=withUpdateSlugs(schemas.update.parse(values));if(!await lockRow(tx,id))return null;return await applyPatch(tx,id,patch)})};const applyPatch=async(tx,id,patch)=>{{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{changedFields:changedFields,row:toRow(current)}}await assertContentFileReferences(c,definition,patch,tx);if(changedCollections.length>0)await store?.write(tx,id,patch);const[row]=await tx.update(table).set(changedPaths.length>0?changedPathsToColumns(fields,patch,changedPaths):{updatedAt:new Date}).where(eq(primaryCursor,id)).returning(ownSelection());return{changedFields:changedFields,row:toRow(row)}}};const runCollection=async(itemId,field,compute,options)=>await inTransaction(options,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 applyPatch(tx,itemId,schemas.update.parse({[field]:next}))});const collectionApi={read:async(itemId,field,options)=>{const loaded=await store?.load(itemId,db(options),[field]);const value=loaded?.[field];return Array.isArray(value)?value:[]},run:runCollection,write:async(itemId,field,next,options)=>await service.update(itemId,{[field]:[...next]},options)};const{relations,repeatables}=contentCollectionKinds(definition,store?.fields??[]);for(const field of relations){mutableRelations[field]=buildContentRelationOperations({api:collectionApi,contentTypeId,field})}for(const field of repeatables){mutableRepeatables[field]=buildContentRepeatableOperations({api:collectionApi,contentTypeId,field})}return{...service,...publication?publicationMethods:{}}};

package/dist/src/content/server/slug-history-model.d.ts

@@ -0,0 +1,58 @@
+import type { Context } from "hono";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentDatabase } from "./service";
+export interface ContentSlugHistoryEntry {
+    createdAt: Date;
+    itemId: number;
+    languageId: null | number;
+    path: string;
+    retiredAt: Date | null;
+    slug: string;
+}
+export interface ContentSlugHistoryTarget {
+    itemId: number;
+    languageId: null | number;
+    locale: null | string;
+    slug: string;
+}
+export interface ContentSlugHistoryModel {
+    assertAvailable: (tx: ContentDatabase, args: ContentSlugHistoryTarget) => Promise<void>;
+    ensureCurrent: (tx: ContentDatabase, args: ContentSlugHistoryTarget & {
+        path: string;
+    }) => Promise<{
+        created: boolean;
+    }>;
+    list: (args: {
+        itemId: number;
+        languageId?: null | number;
+        limit?: number;
+    }, database?: ContentDatabase) => Promise<ContentSlugHistoryEntry[]>;
+    owner: (args: {
+        languageId: null | number;
+        slug: string;
+    }, database?: ContentDatabase) => Promise<ContentSlugHistoryEntry | null>;
+    reserve: (tx: ContentDatabase, args: ContentSlugHistoryTarget & {
+        path: string;
+    }) => Promise<{
+        created: boolean;
+    }>;
+    retire: (tx: ContentDatabase, args: Omit<ContentSlugHistoryTarget, "locale">) => Promise<{
+        retired: boolean;
+    }>;
+}
+export declare const createContentSlugHistoryModel: ({ c, definition, pluginId, }: {
+    c: Context;
+    definition: AnyContentTypeDefinition;
+    pluginId: string;
+}) => ContentSlugHistoryModel;
+export declare const contentSlugHistoryCurrentPaths: (database: ContentDatabase, { contentTypeId, itemIds, languageId, }: {
+    contentTypeId: string;
+    itemIds: readonly number[];
+    languageId: null | number;
+}) => Promise<Map<number, string>>;
+export declare const contentSlugHistoryPath: ({ definition, locale, slug, }: {
+    definition: AnyContentTypeDefinition;
+    locale: null | string;
+    slug: string;
+}) => string;
+//# sourceMappingURL=slug-history-model.d.ts.map

package/dist/src/content/server/slug-history-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slug-history-model.d.ts","sourceRoot":"","sources":["../../../../src/content/server/slug-history-model.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,eAAe,EAAE,MAAM,WAAW,CAAC;AAajD,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,IAAI,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IAEf,UAAU,EAAE,IAAI,GAAG,MAAM,CAAC;IAE1B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;CACd;AAUD,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAC;IAEf,UAAU,EAAE,IAAI,GAAG,MAAM,CAAC;IAE1B,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CACd;AAgBD,MAAM,WAAW,uBAAuB;IAUtC,eAAe,EAAE,CACf,EAAE,EAAE,eAAe,EACnB,IAAI,EAAE,wBAAwB,KAC3B,OAAO,CAAC,IAAI,CAAC,CAAC;IAuBnB,aAAa,EAAE,CACb,EAAE,EAAE,eAAe,EACnB,IAAI,EAAE,wBAAwB,GAAG;QAE/B,IAAI,EAAE,MAAM,CAAC;KACd,KACE,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAOnC,IAAI,EAAE,CACJ,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,EACpE,QAAQ,CAAC,EAAE,eAAe,KACvB,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAAC;IAQxC,KAAK,EAAE,CACL,IAAI,EAAE;QAAE,UAAU,EAAE,IAAI,GAAG,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EACjD,QAAQ,CAAC,EAAE,eAAe,KACvB,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAAC;IAY7C,OAAO,EAAE,CACP,EAAE,EAAE,eAAe,EACnB,IAAI,EAAE,wBAAwB,GAAG;QAE/B,IAAI,EAAE,MAAM,CAAC;KACd,KACE,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IASnC,MAAM,EAAE,CACN,EAAE,EAAE,eAAe,EACnB,IAAI,EAAE,IAAI,CAAC,wBAAwB,EAAE,QAAQ,CAAC,KAC3C,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACpC;AA0CD,eAAO,MAAM,6BAA6B,GAAI,8BAI3C;IACD,CAAC,EAAE,OAAO,CAAC;IACX,UAAU,EAAE,wBAAwB,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB,KAAG,uBAyKH,CAAC;AASF,eAAO,MAAM,8BAA8B,GACzC,UAAU,eAAe,EACzB,yCAIG;IACD,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,UAAU,EAAE,IAAI,GAAG,MAAM,CAAC;CAC3B,KACA,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAmB7B,CAAC;AAWF,eAAO,MAAM,sBAAsB,GAAI,+BAIpC;IACD,UAAU,EAAE,wBAAwB,CAAC;IACrC,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CACd,KAAG,MAAiE,CAAC"}

package/dist/src/content/server/slug-history-model.js

@@ -0,0 +1 @@
+import{and,asc,desc,eq,inArray,isNull,sql}from"drizzle-orm";import{core_content_slug_history}from"../../database/content.js";import{contentDeliveryPath}from"../delivery.js";import{ContentDeliverySlugReserved}from"../errors.js";const HISTORY_LIST_LIMIT=50;const languageCondition=(languageId,column)=>languageId===null?isNull(column):eq(column,languageId);const toEntry=row=>({createdAt:row.createdAt,itemId:row.itemId,languageId:row.languageId,path:row.path,retiredAt:row.retiredAt,slug:row.slug});const ENTRY_COLUMNS={createdAt:core_content_slug_history.createdAt,itemId:core_content_slug_history.itemId,languageId:core_content_slug_history.languageId,path:core_content_slug_history.path,retiredAt:core_content_slug_history.retiredAt,slug:core_content_slug_history.slug};export const createContentSlugHistoryModel=({c,definition,pluginId})=>{const contentTypeId=definition.id;const scope=eq(core_content_slug_history.contentTypeId,contentTypeId);const findOwner=async(database,{languageId,slug},{lock=false}={})=>{const query=database.select(ENTRY_COLUMNS).from(core_content_slug_history).where(and(scope,eq(core_content_slug_history.slug,slug),languageCondition(languageId,core_content_slug_history.languageId))).limit(1);const[row]=lock?await query.for("update"):await query;return row?toEntry(row):null};const claim=async(tx,{itemId,languageId,locale,path,slug})=>{const[inserted]=await tx.insert(core_content_slug_history).values({contentTypeId,itemId,languageId,path,pluginId,slug}).onConflictDoNothing().returning({id:core_content_slug_history.id});if(inserted)return{created:true};const owner=await findOwner(tx,{languageId,slug},{lock:true});if(owner?.itemId!==itemId){throw new ContentDeliverySlugReserved({contentTypeId,locale,slug})}return{created:false}};return{assertAvailable:async(tx,{itemId,languageId,locale,slug})=>{const owner=await findOwner(tx,{languageId,slug});if(owner===null||owner.itemId===itemId)return;throw new ContentDeliverySlugReserved({contentTypeId,locale,slug})},ensureCurrent:async(tx,args)=>await claim(tx,args),list:async({itemId,languageId,limit},database)=>{const conditions=[scope,eq(core_content_slug_history.itemId,itemId)];if(languageId!==undefined){conditions.push(languageCondition(languageId,core_content_slug_history.languageId))}const rows=await (database??c.get("db")).select(ENTRY_COLUMNS).from(core_content_slug_history).where(and(...conditions)).orderBy(asc(core_content_slug_history.retiredAt),desc(core_content_slug_history.id)).limit(Math.min(limit??HISTORY_LIST_LIMIT,HISTORY_LIST_LIMIT));return rows.map(toEntry)},owner:async(args,database)=>await findOwner(database??c.get("db"),args),reserve:async(tx,args)=>{const{created}=await claim(tx,args);if(created)return{created:true};const{itemId,languageId,path,slug}=args;await tx.update(core_content_slug_history).set({path,retiredAt:null}).where(and(scope,eq(core_content_slug_history.itemId,itemId),eq(core_content_slug_history.slug,slug),languageCondition(languageId,core_content_slug_history.languageId)));return{created:false}},retire:async(tx,{itemId,languageId,slug})=>{const rows=await tx.update(core_content_slug_history).set({retiredAt:sql`now()`}).where(and(scope,eq(core_content_slug_history.itemId,itemId),eq(core_content_slug_history.slug,slug),languageCondition(languageId,core_content_slug_history.languageId),isNull(core_content_slug_history.retiredAt))).returning({id:core_content_slug_history.id});return{retired:rows.length>0}}}};export const contentSlugHistoryCurrentPaths=async(database,{contentTypeId,itemIds,languageId})=>{if(itemIds.length===0)return new Map;const rows=await database.select({itemId:core_content_slug_history.itemId,path:core_content_slug_history.path}).from(core_content_slug_history).where(and(eq(core_content_slug_history.contentTypeId,contentTypeId),inArray(core_content_slug_history.itemId,[...itemIds]),languageCondition(languageId,core_content_slug_history.languageId),isNull(core_content_slug_history.retiredAt)));return new Map(rows.map(row=>[row.itemId,row.path]))};export const contentSlugHistoryPath=({definition,locale,slug})=>contentDeliveryPath({definition,locale,slug})??"";

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

@@ -0,0 +1,7 @@
+import type { ContentFieldMap } from "../types";
+export interface ContentSlugNormalizer {
+    withCreateSlugs: (values: Record<string, unknown>) => Record<string, unknown>;
+    withUpdateSlugs: (patch: Record<string, unknown>) => Record<string, unknown>;
+}
+export declare const createSlugNormalizer: (contentTypeId: string, fields: ContentFieldMap) => ContentSlugNormalizer;
+//# sourceMappingURL=slugs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slugs.d.ts","sourceRoot":"","sources":["../../../../src/content/server/slugs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AA6BhD,MAAM,WAAW,qBAAqB;IAEpC,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE9E,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9E;AASD,eAAO,MAAM,oBAAoB,GAC/B,eAAe,MAAM,EACrB,QAAQ,eAAe,KACtB,qBA0EF,CAAC"}

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

@@ -0,0 +1 @@
+import{CONTENT_SLUG_DEFAULT_LENGTH}from"../const.js";import{ContentInputError}from"../errors.js";import{slugify}from"../slug.js";const slugFieldsOf=fields=>{const slugFields=[];for(const[name,fieldValue]of Object.entries(fields)){if(fieldValue.kind!=="slug")continue;slugFields.push({maxLength:fieldValue.maxLength??CONTENT_SLUG_DEFAULT_LENGTH,name,source:fieldValue.source})}return slugFields};export const createSlugNormalizer=(contentTypeId,fields)=>{const slugFields=slugFieldsOf(fields);const toSlug=(slugField,value,derived)=>{const slug=slugify(value,slugField.maxLength);if(slug!=="")return slug;throw new ContentInputError(derived?`Could not derive "${slugField.name}" from "${slugField.source}". Send "${slugField.name}" explicitly.`:`Field "${slugField.name}" normalises to an empty slug. Use at least one letter or digit.`,{contentTypeId})};return{withCreateSlugs:values=>{if(slugFields.length===0)return values;const next={...values};for(const slugField of slugFields){const supplied=next[slugField.name];if(typeof supplied==="string"){next[slugField.name]=toSlug(slugField,supplied,false);continue}const source=slugField.source??"";const from=next[source];next[slugField.name]=toSlug(slugField,typeof from==="string"?from:"",true)}return next},withUpdateSlugs:patch=>{if(slugFields.length===0)return patch;const next={...patch};for(const slugField of slugFields){const supplied=next[slugField.name];if(typeof supplied!=="string")continue;next[slugField.name]=toSlug(slugField,supplied,false)}return next}}};

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

@@ -0,0 +1,9 @@
+import type { PgColumn, PgTable } from "drizzle-orm/pg-core";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentColumnName, ContentReferences, ContentTableFor } from "./types";
+export declare const createContentTable: <TDefinition extends AnyContentTypeDefinition>(definition: TDefinition, { references, }?: {
+    references?: ContentReferences<TDefinition["fields"]>;
+}) => ContentTableFor<TDefinition>;
+export declare const assertContentReferences: (table: PgTable) => void;
+export declare const contentTableColumns: <TDefinition extends AnyContentTypeDefinition>(definition: TDefinition, table: ContentTableFor<TDefinition>) => Record<ContentColumnName<TDefinition>, PgColumn>;
+//# sourceMappingURL=table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/content/server/table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,QAAQ,EACR,OAAO,EACR,MAAM,qBAAqB,CAAC;AAU7B,OAAO,KAAK,EACV,wBAAwB,EAGzB,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,EACV,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EAChB,MAAM,SAAS,CAAC;AAkHjB,eAAO,MAAM,kBAAkB,GAC7B,WAAW,SAAS,wBAAwB,EAE5C,YAAY,WAAW,EACvB,kBAEG;IACD,UAAU,CAAC,EAAE,iBAAiB,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC;CAClD,KACL,eAAe,CAAC,WAAW,CAwE7B,CAAC;AAWF,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,IAIxD,CAAC;AAYF,eAAO,MAAM,mBAAmB,GAC9B,WAAW,SAAS,wBAAwB,EAE5C,YAAY,WAAW,EACvB,OAAO,eAAe,CAAC,WAAW,CAAC,KAClC,MAAM,CAAC,iBAAiB,CAAC,WAAW,CAAC,EAAE,QAAQ,CAoBjD,CAAC"}

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

@@ -0,0 +1 @@
+import{getColumnTable,getTableName}from"drizzle-orm";import{camelCase,getTableConfig,index,uniqueIndex}from"drizzle-orm/pg-core";import{core_files}from"../../database/files.js";import{core_users}from"../../database/users.js";import{CONTENT_EDITORIAL_FIELDS,CONTENT_PUBLICATION_FIELDS}from"../const.js";import{ContentEngineError}from"../errors.js";import{partitionContentFields}from"../localization.js";import{contentStorageColumns}from"../paths.js";import{buildContentColumn,buildEditorialColumns,buildPublicationColumns,buildSystemColumns}from"./column-builders.js";const checkedReference=(contentTypeId,name,expectedTableName,thunk)=>{return()=>{const column=thunk();if(!column){throw new ContentEngineError(`\`references.${name}\` resolved to nothing. Rebuild the plugin (\`build:plugins\`), and make sure the target table is exported from its \`src/database\` module.`,{contentTypeId})}const actual=getTableName(getColumnTable(column));const expected=expectedTableName();if(actual!==expected){throw new ContentEngineError(`Relation field "${name}" targets "${expected}", but \`references.${name}\` points at "${actual}". Make both sides agree.`,{contentTypeId})}return column}};const resolveReference=(contentTypeId,name,fields,references)=>{const fieldValue=fields[name];if(fieldValue.kind==="user"){return checkedReference(contentTypeId,name,()=>getTableName(core_users),()=>core_users.id)}if(fieldValue.kind==="file"){return checkedReference(contentTypeId,name,()=>getTableName(core_files),()=>core_files.id)}if(fieldValue.kind!=="relation")return undefined;const thunk=references[name];if(!thunk){throw new ContentEngineError(fieldValue.self?`Self-relation "${name}" should not have an entry in \`references\` - the engine resolves it from the table it is building. This is an internal error.`:`Relation field "${name}" has no entry in \`references\`. Add \`${name}: () => <target_table>.id\`.`,{contentTypeId})}return checkedReference(contentTypeId,name,()=>fieldValue.target().tableName,thunk)};export const createContentTable=(definition,{references={}}={})=>{if(definition===undefined){throw new ContentEngineError("createContentModel was called with no definition. Rebuild the plugin (`build:plugins`); if that does not help, check for a circular import between `src/database` and `src/content`.")}const{id:contentTypeId,indexes,tableName}=definition;const fields=contentStorageColumns(partitionContentFields(definition.fields).sharedFields);const referenceThunks=references;const columns={...buildSystemColumns(),...definition.publication.enabled?buildPublicationColumns():{},...definition.editorial.enabled?buildEditorialColumns():{}};for(const name of Object.keys(fields)){columns[name]=buildContentColumn({contentTypeId,fieldValue:fields[name],name,reference:resolveReference(contentTypeId,name,fields,referenceThunks)})}const declaredFields=definition.fields;const unknownReference=Object.keys(referenceThunks).find(name=>declaredFields[name]?.kind!=="relation");if(unknownReference!==undefined){throw new ContentEngineError(`\`references\` has an entry for "${unknownReference}", which is not a relation field.`,{contentTypeId})}const buildIndexes=columnMap=>indexes.map(config=>{const[first,...rest]=config.on.map(name=>columnMap[name]);return config.unique?uniqueIndex(config.name).on(first,...rest):index(config.name).on(first,...rest)});return camelCase.table.withRLS(tableName,()=>columns,table=>buildIndexes(table))};export const assertContentReferences=table=>{for(const foreignKey of getTableConfig(table).foreignKeys){foreignKey.reference()}};export const contentTableColumns=(definition,table)=>{const source=table;const{sharedFields}=partitionContentFields(definition.fields);const names=["id","createdAt","updatedAt",...definition.publication.enabled?CONTENT_PUBLICATION_FIELDS:[],...definition.editorial.enabled?CONTENT_EDITORIAL_FIELDS:[],...Object.keys(contentStorageColumns(sharedFields))];return{...Object.fromEntries(names.map(name=>[name,source[name]])),...Object.fromEntries(definition.advanced.leaves.filter(leaf=>!leaf.localized).map(leaf=>[leaf.path,source[leaf.columnName]]))}};