@vitnode/core 0.0.1-canary.0

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

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

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

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

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

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

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

@@ -0,0 +1,42 @@
+import type { PgColumn, PgTableWithColumns, TableConfig } from "drizzle-orm/pg-core";
+import type { Context } from "hono";
+import type { AnyContentTypeDefinition, ContentPublicFilterInput, ContentPublicListRow, ContentPublicOrderableFieldName, ContentPublicSelect } from "../types";
+import type { ContentAdvancedStore } from "./advanced-store";
+import type { ContentPageInfo } from "./service";
+export interface ContentPublicReadOptions {
+    locale?: string;
+}
+export interface ContentPublicFindManyArgs<TDefinition> extends ContentPublicReadOptions {
+    filters?: ContentPublicFilterInput<TDefinition>;
+    orderBy?: {
+        column?: ContentPublicOrderableFieldName<TDefinition>;
+        order?: "asc" | "desc";
+    };
+    query?: {
+        cursor?: string;
+        first?: string;
+        last?: string;
+        search?: string;
+    };
+}
+export interface ContentPublicService<TDefinition> {
+    findById: (id: number, options?: ContentPublicReadOptions) => Promise<ContentPublicSelect<TDefinition> | null>;
+    findBySlug: (slug: string, options?: ContentPublicReadOptions) => Promise<ContentPublicSelect<TDefinition> | null>;
+    findMany: (args?: ContentPublicFindManyArgs<TDefinition>) => Promise<{
+        edges: ContentPublicListRow<TDefinition>[];
+        pageInfo: ContentPageInfo;
+    }>;
+}
+export declare const createContentPublicProjector: <TDefinition extends AnyContentTypeDefinition>(definition: TDefinition) => ((row: Record<string, unknown>) => ContentPublicSelect<TDefinition>);
+export declare const contentPublicSelection: (definition: AnyContentTypeDefinition, columns: Record<string, PgColumn>) => Record<string, PgColumn>;
+export declare const contentPublicCollectionFields: (definition: AnyContentTypeDefinition) => string[];
+export declare const nestContentPublicRow: (row: Record<string, unknown>) => Record<string, unknown>;
+export declare const clampContentPublicPageSize: (value: string | undefined) => string | undefined;
+export declare const createContentPublicService: <TDefinition extends AnyContentTypeDefinition>({ advanced, c, columns, definition, table, }: {
+    advanced?: ContentAdvancedStore;
+    c: Context;
+    columns: Record<string, PgColumn>;
+    definition: TDefinition;
+    table: PgTableWithColumns<TableConfig>;
+}) => ContentPublicService<TDefinition>;
+//# sourceMappingURL=public-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"public-service.d.ts","sourceRoot":"","sources":["../../../../src/content/server/public-service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,QAAQ,EACR,kBAAkB,EAClB,WAAW,EACZ,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAKpC,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACxB,oBAAoB,EACpB,+BAA+B,EAC/B,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AA6BjD,MAAM,WAAW,wBAAwB;IAUvC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,yBAAyB,CACxC,WAAW,CACX,SAAQ,wBAAwB;IAEhC,OAAO,CAAC,EAAE,wBAAwB,CAAC,WAAW,CAAC,CAAC;IAChD,OAAO,CAAC,EAAE;QACR,MAAM,CAAC,EAAE,+BAA+B,CAAC,WAAW,CAAC,CAAC;QACtD,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;KACxB,CAAC;IAEF,KAAK,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7E;AASD,MAAM,WAAW,oBAAoB,CAAC,WAAW;IAE/C,QAAQ,EAAE,CACR,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,wBAAwB,KAC/B,OAAO,CAAC,mBAAmB,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,CAAC;IAStD,UAAU,EAAE,CACV,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,wBAAwB,KAC/B,OAAO,CAAC,mBAAmB,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,CAAC;IACtD,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,yBAAyB,CAAC,WAAW,CAAC,KAAK,OAAO,CAAC;QACnE,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,EAAE,CAAC;QAC3C,QAAQ,EAAE,eAAe,CAAC;KAC3B,CAAC,CAAC;CACJ;AAgBD,eAAO,MAAM,4BAA4B,GACvC,WAAW,SAAS,wBAAwB,EAE5C,YAAY,WAAW,KACtB,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,mBAAmB,CAAC,WAAW,CAAC,CAgFrE,CAAC;AAeF,eAAO,MAAM,sBAAsB,GACjC,YAAY,wBAAwB,EACpC,SAAS,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAChC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAoBxB,CAAC;AAQH,eAAO,MAAM,6BAA6B,GACxC,YAAY,wBAAwB,KACnC,MAAM,EAkBR,CAAC;AAUF,eAAO,MAAM,oBAAoB,GAC/B,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAiBxB,CAAC;AAGF,eAAO,MAAM,0BAA0B,GACrC,OAAO,MAAM,GAAG,SAAS,KACxB,MAAM,GAAG,SAOX,CAAC;AAoBF,eAAO,MAAM,0BAA0B,GACrC,WAAW,SAAS,wBAAwB,EAC5C,8CAMC;IAED,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,CAAC,EAAE,OAAO,CAAC;IACX,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAClC,UAAU,EAAE,WAAW,CAAC;IACxB,KAAK,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC;CACxC,KAAG,oBAAoB,CAAC,WAAW,CAgKnC,CAAC"}

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

@@ -0,0 +1 @@
+import{and,eq}from"drizzle-orm";import{withPagination}from"../../api/lib/with-pagination.js";import{CONTENT_PUBLIC_DEFAULT_PAGE_SIZE,CONTENT_PUBLIC_MAX_PAGE_SIZE}from"../const.js";import{ContentEngineError}from"../errors.js";import{isContentReferenceCollection,splitContentFieldPath}from"../paths.js";import{publicOrderableColumns}from"../registry.js";import{groupPublicLeafPaths}from"../schemas.js";import{resolveContentPublicRowFiles}from"./files.js";import{publicationColumns,publishedCondition}from"./publication.js";import{buildFilterCondition,buildOrderColumn,buildSearchCondition}from"./query.js";export const createContentPublicProjector=definition=>{const publicApi=definition.publicApi;if(!publicApi.enabled){throw new ContentEngineError("This content type has no public API, so there is no public projection to build.",{contentTypeId:definition.id})}const exposed=publicApi.fields;const exposesId=exposed.includes("id");const flat=exposed.filter(name=>splitContentFieldPath(name)===null);const exposedToOne=new Set(flat.filter(name=>definition.fields[name]?.kind==="relation"&&!isContentReferenceCollection(definition.fields[name])));const exposedToMany=new Set(flat.filter(name=>definition.fields[name]!==undefined&&isContentReferenceCollection(definition.fields[name])));const containers=[...groupPublicLeafPaths(exposed)].map(([owner,leaves])=>({leaves,owner,repeatable:definition.fields[owner]?.kind==="repeatable"}));return row=>{const projected={};for(const name of flat){if(exposedToMany.has(name)){const ids=row[name];projected[name]=Array.isArray(ids)?ids:[];continue}if(!exposedToOne.has(name)){projected[name]=row[name];continue}const id=row[name];projected[name]=typeof id==="number"?{id}:null}for(const{leaves,owner,repeatable}of containers){const value=row[owner];if(repeatable){projected[owner]=Array.isArray(value)?value.map(child=>({id:child.id,...pick(child,leaves)})):[];continue}projected[owner]=value===null||value===undefined?null:pick(value,leaves)}if(exposesId)projected.id=row.id;return projected}};const pick=(values,keys)=>Object.fromEntries(keys.map(key=>[key,values[key]??null]));export const contentPublicSelection=(definition,columns)=>({id:columns.id,...Object.fromEntries(definition.publicApi.fields.filter(name=>{const path=splitContentFieldPath(name);const owner=path?path[0]:name;const fieldValue=definition.fields[owner];if(!fieldValue)return true;if(fieldValue.kind==="repeatable")return false;return!isContentReferenceCollection(fieldValue)}).map(name=>[name,columns[name]]))});export const contentPublicCollectionFields=definition=>{const named=new Set(definition.publicApi.fields.map(name=>{const path=splitContentFieldPath(name);return path?path[0]:name}));return[...named].filter(name=>{const fieldValue=definition.fields[name];return fieldValue!==undefined&&(fieldValue.kind==="repeatable"||isContentReferenceCollection(fieldValue))})};export const nestContentPublicRow=row=>{const nested={};for(const[key,value]of Object.entries(row)){const path=splitContentFieldPath(key);if(!path){nested[key]=value;continue}const[owner,leaf]=path;const container=nested[owner]??{};container[leaf]=value;nested[owner]=container}return nested};export const clampContentPublicPageSize=value=>{if(value===undefined)return undefined;const parsed=Number.parseInt(value,10);if(!Number.isFinite(parsed))return value;return String(Math.min(parsed,CONTENT_PUBLIC_MAX_PAGE_SIZE))};export const createContentPublicService=({advanced,c,columns,definition,table})=>{const contentTypeId=definition.id;const publicApi=definition.publicApi;if(!publicApi.enabled){throw new ContentEngineError("This content type has no public API. Add `publicApi: { enabled: true, path, fields }` to generate one.",{contentTypeId})}const fields=definition.fields;const published=publicationColumns(definition,columns);const primaryCursor=columns.id;const searchColumns=publicApi.searchableFields.map(name=>columns[name]);const orderable=publicOrderableColumns(definition);const selection=()=>contentPublicSelection(definition,columns);const project=createContentPublicProjector(definition);const publicCollections=contentPublicCollectionFields(definition);const withCollections=async rows=>{const nested=rows.map(nestContentPublicRow);if(nested.length===0)return nested;const ids=nested.map(row=>row.id).filter(id=>typeof id==="number");const loaded=publicCollections.length===0?undefined:await advanced?.loadMany(ids,c.get("db"),publicCollections);const withCollectionValues=loaded===undefined?nested:nested.map(row=>({...row,...typeof row.id==="number"?loaded.get(row.id):undefined}));return await resolveContentPublicRowFiles(c,definition,withCollectionValues)};const readOne=async condition=>{const[row]=await c.get("db").select(selection()).from(table).where(and(publishedCondition(published),condition)).limit(1);if(!row)return null;const[projected]=await withCollections([row]);return project(projected)};return{findById:async id=>await readOne(eq(primaryCursor,id)),findBySlug:async slug=>await readOne(eq(columns[publicApi.slugField],slug)),findMany:async({filters={},orderBy,query={}}={})=>{const conditions=[publishedCondition(published),buildFilterCondition({allowed:publicApi.filterableFields,columns,contentTypeId,fields,filters,membership:advanced?.membershipCondition}),buildSearchCondition(searchColumns,query.search)].filter(item=>item!==undefined);const data=await withPagination({c,params:{query:{...query,first:clampContentPublicPageSize(query.first),last:clampContentPublicPageSize(query.last),search:undefined}},primaryCursor,orderBy:{column:buildOrderColumn({columns,contentTypeId,fallback:publicApi.defaultOrderBy,orderBy:orderBy?.column,orderable}),order:orderBy?.order??publicApi.defaultOrder},table,where:conditions.length>1?and(...conditions):conditions[0],query:async({cursorSelection,limit,orderBy:order,where})=>await c.get("db").select({...selection(),...cursorSelection}).from(table).where(where).orderBy(order).limit(typeof limit==="number"?Math.min(limit,CONTENT_PUBLIC_MAX_PAGE_SIZE+1):CONTENT_PUBLIC_DEFAULT_PAGE_SIZE)});return{edges:(await withCollections(data.edges)).map(project),pageInfo:data.pageInfo}}}};

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

@@ -0,0 +1,14 @@
+import type { SQL } from "drizzle-orm";
+import type { PgColumn } from "drizzle-orm/pg-core";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentPublicationMethods, ContentService } from "./service";
+export interface PublicationColumns {
+    publishedAt: PgColumn;
+    status: PgColumn;
+}
+export declare const publicationColumns: (definition: AnyContentTypeDefinition, columns: Record<string, PgColumn>) => PublicationColumns;
+export declare const publishedCondition: (columns: PublicationColumns) => SQL | undefined;
+export declare const contentTranslationPublicationColumns: (definition: AnyContentTypeDefinition, translationColumns: Record<string, PgColumn>) => PublicationColumns;
+export declare const contentPublicCondition: (base: PublicationColumns, translation?: PublicationColumns) => SQL | undefined;
+export declare const publicationMethods: <TDefinition extends AnyContentTypeDefinition>(definition: TDefinition, service: ContentService<TDefinition>) => ContentPublicationMethods<TDefinition>;
+//# sourceMappingURL=publication.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"publication.d.ts","sourceRoot":"","sources":["../../../../src/content/server/publication.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAa3E,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,QAAQ,CAAC;IACtB,MAAM,EAAE,QAAQ,CAAC;CAClB;AAYD,eAAO,MAAM,kBAAkB,GAC7B,YAAY,wBAAwB,EACpC,SAAS,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAChC,kBAWF,CAAC;AAwCF,eAAO,MAAM,kBAAkB,GAC7B,SAAS,kBAAkB,KAC1B,GAAG,GAAG,SAKN,CAAC;AAWJ,eAAO,MAAM,oCAAoC,GAC/C,YAAY,wBAAwB,EACpC,oBAAoB,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAC3C,kBAgBF,CAAC;AAwBF,eAAO,MAAM,sBAAsB,GACjC,MAAM,kBAAkB,EACxB,cAAc,kBAAkB,KAC/B,GAAG,GAAG,SAG2D,CAAC;AAWrE,eAAO,MAAM,kBAAkB,GAC7B,WAAW,SAAS,wBAAwB,EAE5C,YAAY,WAAW,EACvB,SAAS,cAAc,CAAC,WAAW,CAAC,KACnC,yBAAyB,CAAC,WAAW,CASvC,CAAC"}

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

@@ -0,0 +1 @@
+import{and,eq,isNotNull,lte,sql}from"drizzle-orm";import{ContentEngineError}from"../errors.js";export const publicationColumns=(definition,columns)=>{const{publishedAt,status}=columns;if(!definition.publication.enabled||!publishedAt||!status){throw new ContentEngineError("The published predicate needs `publication: { enabled: true }` on the content type.",{contentTypeId:definition.id})}return{publishedAt,status}};export const publishedCondition=columns=>and(eq(columns.status,"published"),isNotNull(columns.publishedAt),lte(columns.publishedAt,sql`now()`));export const contentTranslationPublicationColumns=(definition,translationColumns)=>{const{publishedAt,status}=translationColumns;if(!definition.localization.enabled||!definition.publication.enabled||!publishedAt||!status){throw new ContentEngineError("The translation published predicate needs both `localization: { enabled: true }` and `publication: { enabled: true }` on the content type.",{contentTypeId:definition.id})}return{publishedAt,status}};export const contentPublicCondition=(base,translation)=>translation===undefined?publishedCondition(base):and(publishedCondition(base),publishedCondition(translation));export const publicationMethods=(definition,service)=>{if(!definition.publication.enabled){throw new ContentEngineError("publish/unpublish need `publication: { enabled: true }` on the content type.",{contentTypeId:definition.id})}return service};

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

@@ -0,0 +1,27 @@
+import type { SQL } from "drizzle-orm";
+import type { PgColumn } from "drizzle-orm/pg-core";
+import type { ContentFieldMap, ContentRelationFilter } from "../types";
+export declare const escapeLikePattern: (value: string) => string;
+export declare const buildSearchCondition: (columns: readonly PgColumn[], term: string | undefined) => SQL | undefined;
+export declare const buildFilterCondition: ({ allowed, columns, contentTypeId, fields, filters, membership, publication, }: {
+    allowed?: readonly string[];
+    columns: Record<string, PgColumn>;
+    contentTypeId: string;
+    fields: ContentFieldMap;
+    filters: Record<string, unknown>;
+    membership?: (field: string, filter: ContentRelationFilter) => SQL | undefined;
+    publication?: boolean;
+}) => SQL | undefined;
+export declare const buildOrderColumn: ({ columns, contentTypeId, fallback, orderBy, orderable, }: {
+    columns: Record<string, PgColumn>;
+    contentTypeId: string;
+    fallback: string;
+    orderable: readonly string[];
+    orderBy: string | undefined;
+}) => PgColumn;
+export declare const diffChangedFields: <TName extends string>(fieldNames: readonly TName[], current: Record<string, unknown>, patch: Record<string, unknown>) => TName[];
+export declare const diffChangedPaths: (fields: ContentFieldMap, current: Record<string, unknown>, patch: Record<string, unknown>) => string[];
+export declare const changedPathsToColumns: (fields: ContentFieldMap, patch: Record<string, unknown>, changedPaths: readonly string[]) => Record<string, unknown>;
+export declare const toColumnValues: (fields: ContentFieldMap, values: Record<string, unknown>) => Record<string, unknown>;
+export declare const toInsertColumns: (fields: ContentFieldMap, values: Record<string, unknown>) => Record<string, unknown>;
+//# sourceMappingURL=query.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../src/content/server/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD,OAAO,KAAK,EAEV,eAAe,EACf,qBAAqB,EACtB,MAAM,UAAU,CAAC;AAyBlB,eAAO,MAAM,iBAAiB,GAAI,OAAO,MAAM,KAAG,MACD,CAAC;AAElD,eAAO,MAAM,oBAAoB,GAC/B,SAAS,SAAS,QAAQ,EAAE,EAC5B,MAAM,MAAM,GAAG,SAAS,KACvB,GAAG,GAAG,SAOR,CAAC;AAyBF,eAAO,MAAM,oBAAoB,GAAI,gFAQlC;IAMD,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IASjC,UAAU,CAAC,EAAE,CACX,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,qBAAqB,KAC1B,GAAG,GAAG,SAAS,CAAC;IAErB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,KAAG,GAAG,GAAG,SAkFT,CAAC;AAMF,eAAO,MAAM,gBAAgB,GAAI,2DAM9B;IACD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B,KAAG,QAkBH,CAAC;AAoBF,eAAO,MAAM,iBAAiB,GAAI,KAAK,SAAS,MAAM,EACpD,YAAY,SAAS,KAAK,EAAE,EAC5B,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,KAAK,EAGL,CAAC;AAgBJ,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,eAAe,EACvB,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,MAAM,EA6CR,CAAC;AASF,eAAO,MAAM,qBAAqB,GAChC,QAAQ,eAAe,EACvB,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,SAAS,MAAM,EAAE,KAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAqBxB,CAAC;AAGF,eAAO,MAAM,cAAc,GACzB,QAAQ,eAAe,EACvB,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAStB,CAAC;AASJ,eAAO,MAAM,eAAe,GAC1B,QAAQ,eAAe,EACvB,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAItB,CAAC"}

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

@@ -0,0 +1 @@
+import{and,eq,ilike,isNull,or}from"drizzle-orm";import{CONTENT_FILTERABLE_FIELD_KINDS,CONTENT_PUBLICATION_STATUSES,isContentPublicationStatus,isFilterableFieldKind}from"../const.js";import{ContentEngineError}from"../errors.js";import{contentFieldPath,contentInnerFields,contentLeafColumnName,contentStorageColumns,contentValuesToColumns,isContentCollectionField,isContentReferenceCollection,readContentLeaf,splitContentFieldPath}from"../paths.js";export const escapeLikePattern=value=>value.replace(/[\\%_]/g,match=>`\\${match}`);export const buildSearchCondition=(columns,term)=>{const trimmed=term?.trim();if(!columns.length||!trimmed)return undefined;const pattern=`%${escapeLikePattern(trimmed)}%`;return or(...columns.map(column=>ilike(column,pattern)))};const filterValue=(fieldValue,raw)=>{if(fieldValue.kind==="boolean")return raw==="true"||raw===true;return raw};export const buildFilterCondition=({allowed,columns,contentTypeId,fields,filters,membership,publication=false})=>{const conditions=[];for(const[name,raw]of Object.entries(filters)){if(raw===undefined)continue;if(allowed&&!allowed.includes(name)){throw new ContentEngineError(`Filter "${name}" is not in the allowlist. Allowed: ${allowed.length>0?allowed.join(", "):"(none)"}.`,{contentTypeId})}if(publication&&name==="status"&&columns.status){if(!isContentPublicationStatus(raw)){throw new ContentEngineError(`Invalid publication status ${JSON.stringify(raw)}. Allowed values: ${CONTENT_PUBLICATION_STATUSES.join(", ")}.`,{contentTypeId})}conditions.push(eq(columns.status,raw));continue}const fieldValue=fields[name];if(fieldValue&&isContentReferenceCollection(fieldValue)){const filter=raw;if(typeof filter?.contains!=="number"){throw new ContentEngineError(`Filter "${name}" is a to-many relation, which takes \`{ contains: <id> }\` rather than a value.`,{contentTypeId})}const condition=membership?.(name,filter);if(condition)conditions.push(condition);continue}const column=columns[name];if(!fieldValue||!column){throw new ContentEngineError(`Unknown filter "${name}".`,{contentTypeId})}if(!isFilterableFieldKind(fieldValue.kind)){throw new ContentEngineError(`Field "${name}" of kind "${fieldValue.kind}" cannot be used as a generated equality filter. Filterable kinds: ${CONTENT_FILTERABLE_FIELD_KINDS.join(", ")}. Write a custom route for anything else.`,{contentTypeId})}if(raw===null){if(!fieldValue.nullable){throw new ContentEngineError(`Field "${name}" is not nullable, so it can never hold null. Drop the filter, or declare the field \`nullable: true\`.`,{contentTypeId})}conditions.push(isNull(column));continue}conditions.push(eq(column,filterValue(fieldValue,raw)))}if(conditions.length===0)return undefined;return conditions.length===1?conditions[0]:and(...conditions)};export const buildOrderColumn=({columns,contentTypeId,fallback,orderBy,orderable})=>{const name=orderBy??fallback;if(!orderable.includes(name)){throw new ContentEngineError(`Cannot order by "${name}". Allowed: ${orderable.join(", ")}.`,{contentTypeId})}const column=columns[name];if(!column){throw new ContentEngineError(`No column named "${name}".`,{contentTypeId})}return column};const sameValue=(current,next)=>{if(current instanceof Date){if(next===null||next===undefined)return false;return current.getTime()===new Date(next).getTime()}return current===next};export const diffChangedFields=(fieldNames,current,patch)=>fieldNames.filter(name=>patch[name]!==undefined&&!sameValue(current[name],patch[name]));export const diffChangedPaths=(fields,current,patch)=>{const changed=[];for(const[name,fieldValue]of Object.entries(fields)){const next=patch[name];if(next===undefined)continue;if(isContentCollectionField(fieldValue))continue;if(fieldValue.kind!=="group"){if(!sameValue(current[name],next))changed.push(name);continue}const inner=contentInnerFields(fieldValue);if(next===null){for(const leaf of Object.keys(inner)){const stored=readContentLeaf(current,name,leaf);if(stored===null||stored===undefined)continue;changed.push(contentFieldPath(name,leaf))}continue}if(typeof next!=="object")continue;for(const[leaf,leafValue]of Object.entries(next)){if(!(leaf in inner)||leafValue===undefined)continue;if(sameValue(readContentLeaf(current,name,leaf),leafValue))continue;changed.push(contentFieldPath(name,leaf))}}return changed};export const changedPathsToColumns=(fields,patch,changedPaths)=>{const picked={};for(const path of changedPaths){const parts=splitContentFieldPath(path);if(!parts){if(fields[path]===undefined)continue;picked[path]=patch[path];continue}const[owner,leaf]=parts;const container=patch[owner];picked[contentLeafColumnName(owner,leaf)]=container===null?null:container?.[leaf]??null}return toColumnValues(contentStorageColumns(fields),picked)};export const toColumnValues=(fields,values)=>Object.fromEntries(Object.entries(values).map(([name,value])=>{if(fields[name]?.kind!=="dateTime"||typeof value!=="string"){return[name,value]}return[name,new Date(value)]}));export const toInsertColumns=(fields,values)=>toColumnValues(contentStorageColumns(fields),contentValuesToColumns(fields,values));

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

@@ -0,0 +1,32 @@
+import type { PgColumn, PgTable, PgTableWithColumns, TableConfig } from "drizzle-orm/pg-core";
+import type { AnyContentTypeDefinition } from "../types";
+export interface ReferenceTranslationSource {
+    aliased: PgTable;
+    itemColumn: PgColumn;
+    labelColumn: PgColumn;
+    languageColumn: PgColumn;
+}
+export interface ReferenceLocalizedLabel {
+    defaultLocale: string;
+    fallback: ReferenceTranslationSource;
+    viewer: ReferenceTranslationSource;
+}
+export interface ContentPickerTarget {
+    aliased: PgTable;
+    colorColumn?: PgColumn;
+    idColumn: PgColumn;
+    labelColumn: PgColumn;
+    localizedLabel?: ReferenceLocalizedLabel;
+    userColumns?: {
+        avatarColor: PgColumn;
+        nameCode: PgColumn;
+    };
+}
+export interface ReferenceTarget extends ContentPickerTarget {
+    owner: PgColumn;
+}
+export declare const LABEL_PREFIX = "label__";
+export declare const toLabel: (value: unknown) => null | string;
+export declare const resolveReferenceTargets: (definition: AnyContentTypeDefinition, table: PgTableWithColumns<TableConfig>, columns: Record<string, PgColumn>) => Record<string, ReferenceTarget>;
+export declare const resolveCollectionPickerTargets: (definition: AnyContentTypeDefinition, targetTableOf: (field: string) => null | PgTable) => Record<string, ContentPickerTarget>;
+//# sourceMappingURL=references.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../../../../src/content/server/references.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,OAAO,EACP,kBAAkB,EAClB,WAAW,EACZ,MAAM,qBAAqB,CAAC;AAI7B,OAAO,KAAK,EAAE,wBAAwB,EAAyB,MAAM,UAAU,CAAC;AAehF,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,QAAQ,CAAC;IACrB,WAAW,EAAE,QAAQ,CAAC;IACtB,cAAc,EAAE,QAAQ,CAAC;CAC1B;AAYD,MAAM,WAAW,uBAAuB;IAEtC,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,0BAA0B,CAAC;IACrC,MAAM,EAAE,0BAA0B,CAAC;CACpC;AAUD,MAAM,WAAW,mBAAmB;IAElC,OAAO,EAAE,OAAO,CAAC;IAOjB,WAAW,CAAC,EAAE,QAAQ,CAAC;IACvB,QAAQ,EAAE,QAAQ,CAAC;IASnB,WAAW,EAAE,QAAQ,CAAC;IAEtB,cAAc,CAAC,EAAE,uBAAuB,CAAC;IASzC,WAAW,CAAC,EAAE;QAAE,WAAW,EAAE,QAAQ,CAAC;QAAC,QAAQ,EAAE,QAAQ,CAAA;KAAE,CAAC;CAC7D;AAGD,MAAM,WAAW,eAAgB,SAAQ,mBAAmB;IAC1D,KAAK,EAAE,QAAQ,CAAC;CACjB;AAED,eAAO,MAAM,YAAY,YAAY,CAAC;AAOtC,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,IAAI,GAAG,MAS/C,CAAC;AA6DF,eAAO,MAAM,uBAAuB,GAClC,YAAY,wBAAwB,EACpC,OAAO,kBAAkB,CAAC,WAAW,CAAC,EACtC,SAAS,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAChC,MAAM,CAAC,MAAM,EAAE,eAAe,CAgChC,CAAC;AAkBF,eAAO,MAAM,8BAA8B,GACzC,YAAY,wBAAwB,EACpC,eAAe,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,KAC/C,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAiBpC,CAAC"}

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

@@ -0,0 +1 @@
+import{alias,getTableConfig}from"drizzle-orm/pg-core";import{ContentEngineError}from"../errors.js";import{partitionContentFields}from"../localization.js";import{isContentReferenceCollection}from"../paths.js";import{createContentTranslationTable}from"./translation-table.js";export const LABEL_PREFIX="label__";export const toLabel=value=>{if(value===null||value===undefined)return null;if(typeof value==="string")return value;if(typeof value==="number"||typeof value==="bigint"){return value.toString()}if(value instanceof Date)return value.toISOString();return null};const translationTables=new WeakMap;const translationSource=(definition,baseTable,labelName,aliasName)=>{const cached=translationTables.get(definition);const translationTable=cached??createContentTranslationTable(definition,{table:baseTable});if(!cached)translationTables.set(definition,translationTable);const aliased=alias(translationTable,aliasName);const columns=aliased;return{aliased,itemColumn:columns.itemId,labelColumn:columns[labelName],languageColumn:columns.languageId}};export const resolveReferenceTargets=(definition,table,columns)=>{const fields=definition.fields;const byOwnerColumn=new Map(getTableConfig(table).foreignKeys.map(foreignKey=>foreignKey.reference()).map(reference=>[reference.columns[0]?.name,reference]));const targets={};for(const[name,fieldValue]of Object.entries(fields)){if(fieldValue.kind!=="relation"&&fieldValue.kind!=="user")continue;if(isContentReferenceCollection(fieldValue))continue;const reference=byOwnerColumn.get(name);if(!reference){throw new ContentEngineError(`Field "${name}" has no foreign key on "${definition.tableName}".`,{contentTypeId:definition.id})}targets[name]={...buildPickerTarget(name,fieldValue,reference.foreignTable),owner:columns[name]}}return targets};export const resolveCollectionPickerTargets=(definition,targetTableOf)=>{const targets={};for(const[name,fieldValue]of Object.entries(definition.fields)){if(!isContentReferenceCollection(fieldValue))continue;if(fieldValue.kind!=="relation"&&fieldValue.kind!=="user")continue;const targetTable=targetTableOf(name);if(!targetTable)continue;targets[name]=buildPickerTarget(name,fieldValue,targetTable)}return targets};const buildPickerTarget=(name,fieldValue,foreignTable)=>{const targetDefinition=fieldValue.kind==="user"?null:fieldValue.target();const labelName=targetDefinition===null?"name":targetDefinition.admin.titleField??"id";const aliased=alias(foreignTable,`${LABEL_PREFIX}${name}`);const aliasedColumns=aliased;const localized=targetDefinition!==null&&targetDefinition.localization.enabled&&labelName in partitionContentFields(targetDefinition.fields).localizedFields?targetDefinition:null;const colorName=targetDefinition?.admin.colorField??null;return{aliased,idColumn:aliasedColumns.id,labelColumn:aliasedColumns[labelName]??aliasedColumns.id,...colorName!==null&&aliasedColumns[colorName]?{colorColumn:aliasedColumns[colorName]}:{},...localized?{localizedLabel:{defaultLocale:localized.localization.defaultLocale,fallback:translationSource(localized,foreignTable,labelName,`${LABEL_PREFIX}${name}__default`),viewer:translationSource(localized,foreignTable,labelName,`${LABEL_PREFIX}${name}__locale`)}}:{},...fieldValue.kind==="user"&&aliasedColumns.avatarColor&&aliasedColumns.nameCode?{userColumns:{avatarColor:aliasedColumns.avatarColor,nameCode:aliasedColumns.nameCode}}:{}}};

package/dist/src/content/server/revalidate-bridge.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from "hono";
+import type { ContentInvalidationInput, ContentInvalidationMode } from "../cache";
+export declare const CONTENT_REVALIDATE_PATH = "/api/vitnode/content/revalidate";
+export declare const CONTENT_REVALIDATE_MAX_SKEW_MS: number;
+export declare const CONTENT_REVALIDATE_TIMESTAMP_HEADER = "x-vitnode-timestamp";
+export interface ContentRevalidationRequest extends ContentInvalidationInput {
+    mode: ContentInvalidationMode;
+}
+export declare const dispatchContentRevalidation: (c: Context, input: ContentRevalidationRequest) => Promise<{
+    attempted: number;
+    delivered: number;
+}>;
+//# sourceMappingURL=revalidate-bridge.d.ts.map

package/dist/src/content/server/revalidate-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revalidate-bridge.d.ts","sourceRoot":"","sources":["../../../../src/content/server/revalidate-bridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,KAAK,EACV,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,UAAU,CAAC;AAMlB,eAAO,MAAM,uBAAuB,oCAAoC,CAAC;AAGzE,eAAO,MAAM,8BAA8B,QAAgB,CAAC;AAE5D,eAAO,MAAM,mCAAmC,wBAAwB,CAAC;AAMzE,MAAM,WAAW,0BAA2B,SAAQ,wBAAwB;IAC1E,IAAI,EAAE,uBAAuB,CAAC;CAC/B;AAsDD,eAAO,MAAM,2BAA2B,GACtC,GAAG,OAAO,EACV,OAAO,0BAA0B,KAChC,OAAO,CAAC;IAET,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,MAAM,CAAC;CACnB,CAsBA,CAAC"}

package/dist/src/content/server/revalidate-bridge.js

@@ -0,0 +1 @@
+import{CONFIG}from"../../lib/config.js";import{contentInvalidationTags}from"../cache.js";export const CONTENT_REVALIDATE_PATH="/api/vitnode/content/revalidate";export const CONTENT_REVALIDATE_MAX_SKEW_MS=5*60*1e3;export const CONTENT_REVALIDATE_TIMESTAMP_HEADER="x-vitnode-timestamp";const ATTEMPTS=2;const RETRY_DELAY_MS=250;const sleep=async ms=>await new Promise(resolve=>setTimeout(resolve,ms));const originsFor=c=>c.get("core")?.contentRevalidateOrigins??[];export const dispatchContentRevalidation=async(c,input)=>{if(contentInvalidationTags(input).length===0){return{attempted:0,delivered:0}}const origins=originsFor(c);if(origins.length===0)return{attempted:0,delivered:0};const secret=c.get("core")?.cronSecret??CONFIG.cronJobSecret;const body=JSON.stringify(input);let delivered=0;for(const origin of origins){if(await post(c,origin,body,secret))delivered+=1}return{attempted:origins.length,delivered}};const post=async(c,origin,body,secret)=>{for(let attempt=1;attempt<=ATTEMPTS;attempt+=1){try{const response=await fetch(new URL(CONTENT_REVALIDATE_PATH,origin).toString(),{body,headers:{authorization:`Bearer ${secret}`,"content-type":"application/json",[CONTENT_REVALIDATE_TIMESTAMP_HEADER]:String(Date.now())},method:"POST"});if(response.ok)return true;if(response.status===403){void log(c,`${origin} refused the revalidation: the shared secret does not match. Check CRON_SECRET on both sides.`);return false}void log(c,`${origin} answered ${response.status}.`)}catch(error){void log(c,`${origin} could not be reached: ${error instanceof Error?error.message:"unknown error"}`)}if(attempt<ATTEMPTS)await sleep(RETRY_DELAY_MS)}return false};const log=async(c,message)=>{const text=`[content-revalidate] ${message}`;try{await c.get("log")?.error(text)}catch{console.error(text)}};

package/dist/src/content/server/revision-snapshot.d.ts

@@ -0,0 +1,12 @@
+import type { ContentRevisionSnapshot, ContentSnapshotValue, ContentTranslationRevisionSnapshot } from "../revisions";
+import type { AnyContentTypeDefinition } from "../types";
+export declare const contentRevisionSnapshot: (definition: AnyContentTypeDefinition, row: object) => ContentRevisionSnapshot;
+export declare const contentSnapshotRow: (snapshot: ContentRevisionSnapshot) => Record<string, unknown>;
+export declare const projectRevisionSnapshot: (definition: AnyContentTypeDefinition, snapshot: ContentRevisionSnapshot) => Record<string, ContentSnapshotValue>;
+export declare const contentTranslationRevisionSnapshot: (definition: AnyContentTypeDefinition, row: object, { languageId, locale }: {
+    languageId: number;
+    locale: string;
+}) => ContentTranslationRevisionSnapshot;
+export declare const contentTranslationSnapshotRow: (snapshot: ContentTranslationRevisionSnapshot) => Record<string, unknown>;
+export declare const projectTranslationRevisionSnapshot: (definition: AnyContentTypeDefinition, snapshot: ContentTranslationRevisionSnapshot) => Record<string, ContentSnapshotValue>;
+//# sourceMappingURL=revision-snapshot.d.ts.map

package/dist/src/content/server/revision-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revision-snapshot.d.ts","sourceRoot":"","sources":["../../../../src/content/server/revision-snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EAEvB,oBAAoB,EACpB,kCAAkC,EACnC,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,wBAAwB,EAAmB,MAAM,UAAU,CAAC;AA2H1E,eAAO,MAAM,uBAAuB,GAClC,YAAY,wBAAwB,EACpC,KAAK,MAAM,KACV,uBAoCF,CAAC;AAYF,eAAO,MAAM,kBAAkB,GAC7B,UAAU,uBAAuB,KAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAMvB,CAAC;AAcH,eAAO,MAAM,uBAAuB,GAClC,YAAY,wBAAwB,EACpC,UAAU,uBAAuB,KAChC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CASrC,CAAC;AA0EF,eAAO,MAAM,kCAAkC,GAC7C,YAAY,wBAAwB,EACpC,KAAK,MAAM,EACX,wBAAwB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,KAC7D,kCAiCF,CAAC;AAGF,eAAO,MAAM,6BAA6B,GACxC,UAAU,kCAAkC,KAC3C,MAAM,CAAC,MAAM,EAAE,OAAO,CAQvB,CAAC;AAYH,eAAO,MAAM,kCAAkC,GAC7C,YAAY,wBAAwB,EACpC,UAAU,kCAAkC,KAC3C,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAIrC,CAAC"}

package/dist/src/content/server/revision-snapshot.js

@@ -0,0 +1 @@
+import{CONTENT_REVISION_SNAPSHOT_VERSION}from"../const.js";import{partitionContentFields}from"../localization.js";import{contentInnerFields,isContentReferenceCollection,readContentLeaf}from"../paths.js";const toIso=value=>{if(value instanceof Date)return value.toISOString();if(typeof value==="string")return value;return new Date(0).toISOString()};const toIsoOrNull=value=>{if(value===null||value===undefined)return null;return toIso(value)};const toSnapshotValue=value=>{if(value===null||value===undefined)return null;if(value instanceof Date)return value.toISOString();const type=typeof value;if(type==="boolean"||type==="number"||type==="string"){return value}return null};const toFieldSnapshot=(name,fieldValue,values)=>{if(fieldValue.kind==="group"){const inner=contentInnerFields(fieldValue);const leaves=Object.keys(inner);const nested={};let allNull=true;for(const leaf of leaves){const snapshot=toSnapshotValue(readContentLeaf(values,name,leaf));if(snapshot!==null)allNull=false;nested[leaf]=snapshot}return fieldValue.nullable&&allNull?null:nested}if(isContentReferenceCollection(fieldValue)){const value=values[name];return Array.isArray(value)?value.map(id=>Number(id)).filter(id=>Number.isInteger(id)):[]}if(fieldValue.kind==="repeatable"){const value=values[name];if(!Array.isArray(value))return[];const leaves=Object.keys(contentInnerFields(fieldValue));return value.map(row=>({id:toSnapshotValue(row.id),...Object.fromEntries(leaves.map(leaf=>[leaf,toSnapshotValue(row[leaf])]))}))}return toSnapshotValue(values[name])};export const contentRevisionSnapshot=(definition,row)=>{const values=row;const fields={};const{collectionFields,sharedFields}=partitionContentFields(definition.fields);const snapshotFields={...sharedFields,...collectionFields};for(const[name,fieldValue]of Object.entries(snapshotFields)){fields[name]=toFieldSnapshot(name,fieldValue,values)}const snapshot={contentTypeId:definition.id,createdAt:toIso(values.createdAt),fields,id:typeof values.id==="number"?values.id:0,schemaVersion:CONTENT_REVISION_SNAPSHOT_VERSION,updatedAt:toIso(values.updatedAt),version:typeof values.version==="number"?values.version:1};if(definition.publication.enabled){snapshot.publication={publishedAt:toIsoOrNull(values.publishedAt),status:typeof values.status==="string"?values.status:"draft"}}return snapshot};export const contentSnapshotRow=snapshot=>({...snapshot.fields,createdAt:snapshot.createdAt,id:snapshot.id,publishedAt:snapshot.publication?.publishedAt??null,updatedAt:snapshot.updatedAt});export const projectRevisionSnapshot=(definition,snapshot)=>{const{collectionFields,sharedFields}=partitionContentFields(definition.fields);return projectSnapshotFields({...sharedFields,...collectionFields},snapshot.fields)};const projectSnapshotFields=(restorable,stored)=>{const projected={};for(const[name,fieldValue]of Object.entries(restorable)){if(!(name in stored))continue;const value=stored[name];if(fieldValue.kind==="group"||fieldValue.kind==="repeatable"){const leaves=Object.keys(contentInnerFields(fieldValue));if(fieldValue.kind==="group"){projected[name]=value===null||typeof value!=="object"||Array.isArray(value)?null:pickLeaves(value,leaves);continue}projected[name]=Array.isArray(value)?value.map(row=>({...typeof row.id==="number"?{id:row.id}:{},...pickLeaves(row,leaves)})):[];continue}projected[name]=value}return projected};const pickLeaves=(values,leaves)=>Object.fromEntries(leaves.filter(leaf=>leaf in values).map(leaf=>[leaf,values[leaf]]));export const contentTranslationRevisionSnapshot=(definition,row,{languageId,locale})=>{const values=row;const fields={};const{localizedFields}=partitionContentFields(definition.fields);for(const[name,fieldValue]of Object.entries(localizedFields)){fields[name]=toFieldSnapshot(name,fieldValue,values)}const snapshot={contentTypeId:definition.id,createdAt:toIso(values.createdAt),fields,itemId:typeof values.itemId==="number"?values.itemId:0,languageId,locale,schemaVersion:CONTENT_REVISION_SNAPSHOT_VERSION,updatedAt:toIso(values.updatedAt),version:typeof values.version==="number"?values.version:1};if(definition.publication.enabled){snapshot.publication={publishedAt:toIsoOrNull(values.publishedAt),status:typeof values.status==="string"?values.status:"draft"}}return snapshot};export const contentTranslationSnapshotRow=snapshot=>({...snapshot.fields,createdAt:snapshot.createdAt,itemId:snapshot.itemId,languageId:snapshot.languageId,publishedAt:snapshot.publication?.publishedAt??null,updatedAt:snapshot.updatedAt,version:snapshot.version});export const projectTranslationRevisionSnapshot=(definition,snapshot)=>{const{localizedFields}=partitionContentFields(definition.fields);return projectSnapshotFields(localizedFields,snapshot.fields)};

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

@@ -0,0 +1,45 @@
+import type { Context } from "hono";
+import type { ContentActor, ContentRevisionDetail, ContentRevisionMeta, ContentRevisionOperation, ContentRevisionSnapshot } from "../revisions";
+import type { AnyContentTypeDefinition } from "../types";
+import type { ContentDatabase } from "./service";
+export interface ContentRevisionCaptureInput<TSnapshot = ContentRevisionSnapshot> {
+    actor: ContentActor;
+    changedFields: readonly string[];
+    fileIds?: readonly number[];
+    itemId: number;
+    operation: ContentRevisionOperation;
+    restoredFromRevisionId?: number;
+    snapshot: TSnapshot;
+    version: number;
+}
+export interface ContentRevisionsModel<TSnapshot = ContentRevisionSnapshot> {
+    capture: (tx: ContentDatabase, input: ContentRevisionCaptureInput<TSnapshot>) => Promise<number>;
+    findById: (itemId: number, revisionId: number, tx?: ContentDatabase) => Promise<ContentRevisionDetail<TSnapshot> | null>;
+    latest: (itemId: number, tx?: ContentDatabase) => Promise<ContentRevisionMeta | null>;
+    list: (itemId: number, args?: {
+        cursor?: number;
+        limit?: number;
+    }) => Promise<ContentRevisionPage>;
+}
+export interface ContentRevisionPage {
+    edges: ContentRevisionMeta[];
+    pageInfo: {
+        endCursor: null | number;
+        hasNextPage: boolean;
+    };
+}
+export declare const CONTENT_REVISIONS_DEFAULT_PAGE_SIZE = 25;
+export declare const CONTENT_REVISIONS_MAX_PAGE_SIZE = 100;
+export declare const createContentRevisionsModel: <TSnapshot = ContentRevisionSnapshot>({ c, definition, languageId, pluginId, }: {
+    c: Context;
+    definition: AnyContentTypeDefinition;
+    languageId?: null | number;
+    pluginId: string;
+}) => ContentRevisionsModel<TSnapshot>;
+export declare const pruneContentRevisions: ({ db, knownContentTypeIds, }: {
+    db: ContentDatabase;
+    knownContentTypeIds: string[];
+}) => Promise<{
+    orphaned: number;
+}>;
+//# sourceMappingURL=revisions-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"revisions-model.d.ts","sourceRoot":"","sources":["../../../../src/content/server/revisions-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAIpC,OAAO,KAAK,EACV,YAAY,EAEZ,qBAAqB,EACrB,mBAAmB,EACnB,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AASjD,MAAM,WAAW,2BAA2B,CAC1C,SAAS,GAAG,uBAAuB;IAEnC,KAAK,EAAE,YAAY,CAAC;IACpB,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAcjC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,wBAAwB,CAAC;IACpC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,EAAE,SAAS,CAAC;IAEpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,qBAAqB,CAAC,SAAS,GAAG,uBAAuB;IAQxE,OAAO,EAAE,CACP,EAAE,EAAE,eAAe,EACnB,KAAK,EAAE,2BAA2B,CAAC,SAAS,CAAC,KAC1C,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,QAAQ,EAAE,CACR,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,EAAE,CAAC,EAAE,eAAe,KACjB,OAAO,CAAC,qBAAqB,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,CAAC;IAStD,MAAM,EAAE,CACN,MAAM,EAAE,MAAM,EACd,EAAE,CAAC,EAAE,eAAe,KACjB,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAAC;IAEzC,IAAI,EAAE,CACJ,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,KACvC,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACnC;AAUD,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B,QAAQ,EAAE;QACR,SAAS,EAAE,IAAI,GAAG,MAAM,CAAC;QACzB,WAAW,EAAE,OAAO,CAAC;KACtB,CAAC;CACH;AAED,eAAO,MAAM,mCAAmC,KAAK,CAAC;AACtD,eAAO,MAAM,+BAA+B,MAAM,CAAC;AAiBnD,eAAO,MAAM,2BAA2B,GACtC,SAAS,GAAG,uBAAuB,EACnC,0CAKC;IACD,CAAC,EAAE,OAAO,CAAC;IACX,UAAU,EAAE,wBAAwB,CAAC;IAErC,UAAU,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;CAClB,KAAG,qBAAqB,CAAC,SAAS,CA0KlC,CAAC;AAUF,eAAO,MAAM,qBAAqB,GAAU,8BAGzC;IACD,EAAE,EAAE,eAAe,CAAC;IACpB,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B,KAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAa/B,CAAC"}

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

@@ -0,0 +1 @@
+import{and,desc,eq,isNull,lt,lte,notInArray,sql}from"drizzle-orm";import{core_content_file_refs,core_content_revisions}from"../../database/content.js";import{core_roles}from"../../database/roles.js";import{core_users}from"../../database/users.js";export const CONTENT_REVISIONS_DEFAULT_PAGE_SIZE=25;export const CONTENT_REVISIONS_MAX_PAGE_SIZE=100;export const createContentRevisionsModel=({c,definition,languageId=null,pluginId})=>{const contentTypeId=definition.id;const retention=definition.editorial.revisions.retention;const scope=itemId=>and(eq(core_content_revisions.pluginId,pluginId),eq(core_content_revisions.contentTypeId,contentTypeId),eq(core_content_revisions.itemId,itemId),languageId===null?isNull(core_content_revisions.languageId):eq(core_content_revisions.languageId,languageId));const metaSelection={actorName:core_users.name,actorRoleColor:core_roles.color,actorType:core_content_revisions.actorType,actorUserId:core_content_revisions.actorUserId,changedFields:core_content_revisions.changedFields,createdAt:core_content_revisions.createdAt,id:core_content_revisions.id,operation:core_content_revisions.operation,restoredFromRevisionId:core_content_revisions.restoredFromRevisionId,version:core_content_revisions.version};return{capture:async(tx,input)=>{const[row]=await tx.insert(core_content_revisions).values({actorType:input.actor.type,actorUserId:input.actor.userId,changedFields:[...input.changedFields],contentTypeId,itemId:input.itemId,languageId,operation:input.operation,pluginId,restoredFromRevisionId:input.restoredFromRevisionId??null,snapshot:input.snapshot,version:input.version}).returning({id:core_content_revisions.id});const fileIds=[...new Set(input.fileIds??[])];if(fileIds.length>0){await tx.insert(core_content_file_refs).values(fileIds.map(fileId=>({fileId,revisionId:row.id})))}const keepFrom=input.version-retention;if(keepFrom>0){await tx.delete(core_content_revisions).where(and(scope(input.itemId),lte(core_content_revisions.version,keepFrom)))}return row.id},findById:async(itemId,revisionId,tx)=>{const[row]=await (tx??c.get("db")).select({...metaSelection,snapshot:core_content_revisions.snapshot}).from(core_content_revisions).leftJoin(core_users,eq(core_content_revisions.actorUserId,core_users.id)).leftJoin(core_roles,eq(core_users.roleId,core_roles.id)).where(and(scope(itemId),eq(core_content_revisions.id,revisionId))).limit(1);return row?row:null},latest:async(itemId,tx)=>{const[row]=await (tx??c.get("db")).select(metaSelection).from(core_content_revisions).leftJoin(core_users,eq(core_content_revisions.actorUserId,core_users.id)).leftJoin(core_roles,eq(core_users.roleId,core_roles.id)).where(scope(itemId)).orderBy(desc(core_content_revisions.version)).limit(1);return row?row:null},list:async(itemId,{cursor,limit}={})=>{const size=Math.min(Math.max(limit??CONTENT_REVISIONS_DEFAULT_PAGE_SIZE,1),CONTENT_REVISIONS_MAX_PAGE_SIZE);const rows=await c.get("db").select(metaSelection).from(core_content_revisions).leftJoin(core_users,eq(core_content_revisions.actorUserId,core_users.id)).leftJoin(core_roles,eq(core_users.roleId,core_roles.id)).where(cursor===undefined?scope(itemId):and(scope(itemId),lt(core_content_revisions.version,cursor))).orderBy(desc(core_content_revisions.version)).limit(size+1);const edges=rows.slice(0,size);return{edges,pageInfo:{endCursor:edges.at(-1)?.version??null,hasNextPage:rows.length>size}}}}};export const pruneContentRevisions=async({db,knownContentTypeIds})=>{const rows=await db.delete(core_content_revisions).where(knownContentTypeIds.length===0?sql`true`:notInArray(core_content_revisions.contentTypeId,knownContentTypeIds)).returning({id:core_content_revisions.id});return{orphaned:rows.length}};