@murumets-ee/content 0.1.0

package/LICENSE

@@ -0,0 +1,94 @@
+Elastic License 2.0 (ELv2)
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject
+to the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set
+of the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other
+notices of the licensor in the software. Any use of the licensor's trademarks
+is subject to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If your company
+makes such a claim, your patent license ends immediately for work on behalf
+of your company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from
+you also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license
+no later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your
+licenses to terminate automatically and permanently.
+
+## No Liability
+
+As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is
+the software the licensor makes available under these terms, including any
+portion of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that organization.
+**control** means ownership of substantially all the assets of an entity, or
+the power to direct the management and policies of an entity (for example, by
+voting right, contract, or otherwise). Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your
+licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

package/README.md

@@ -0,0 +1,15 @@
+# @murumets-ee/content
+
+Content management — localization, publishing workflows, versioning, drafts, and translation status.
+
+Part of [Lumi CMS](https://github.com/murumets-ee/lumi-cms) — a modular, type-safe CMS toolkit for Node.js.
+
+## Install
+
+```bash
+npm install @murumets-ee/content
+```
+
+## License
+
+[Elastic License 2.0 (ELv2)](../../LICENSE)

package/dist/blocks/index.d.ts

@@ -0,0 +1,187 @@
+import { B as BlockDefinition } from '../types-BYeiE1ie.js';
+import * as _murumets_ee_entity from '@murumets-ee/entity';
+
+declare const CodeBlock: BlockDefinition<{
+    readonly code: _murumets_ee_entity.TextField & {
+        readonly required: true;
+    };
+    readonly language: _murumets_ee_entity.SelectField & {
+        options: readonly ["javascript", "typescript", "python", "html", "css", "json", "bash", "sql", "other"];
+    } & Omit<Partial<_murumets_ee_entity.SelectField>, "options">;
+}>;
+
+declare const CTABlock: BlockDefinition<{
+    readonly heading: _murumets_ee_entity.TextField & {
+        readonly required: true;
+        readonly translatable: true;
+    };
+    readonly description: _murumets_ee_entity.TextField & {
+        readonly translatable: true;
+    };
+    readonly buttonText: _murumets_ee_entity.TextField & {
+        readonly required: true;
+        readonly translatable: true;
+    };
+    readonly buttonLink: _murumets_ee_entity.TextField & {
+        readonly required: true;
+    };
+}>;
+
+declare const GalleryBlock: BlockDefinition<{
+    readonly images: _murumets_ee_entity.ReferenceField & {
+        cardinality: "many";
+    } & Partial<Omit<_murumets_ee_entity.ReferenceField, "entity" | "cardinality">>;
+    readonly columns: _murumets_ee_entity.SelectField & {
+        options: readonly ["2", "3", "4"];
+    } & Omit<Partial<_murumets_ee_entity.SelectField>, "options">;
+}>;
+
+declare const HeroBlock: BlockDefinition<{
+    readonly heading: _murumets_ee_entity.TextField & {
+        readonly required: true;
+        readonly translatable: true;
+    };
+    readonly subheading: _murumets_ee_entity.TextField & {
+        readonly translatable: true;
+    };
+    readonly background: _murumets_ee_entity.MediaField & {
+        readonly accept: ["image/*"];
+    };
+    readonly alignment: _murumets_ee_entity.SelectField & {
+        options: readonly ["left", "center", "right"];
+    } & Omit<Partial<_murumets_ee_entity.SelectField>, "options">;
+}>;
+
+declare const ImageBlock: BlockDefinition<{
+    readonly image: _murumets_ee_entity.MediaField & {
+        readonly accept: ["image/*"];
+        readonly required: true;
+    };
+    readonly alt: _murumets_ee_entity.TextField & {
+        readonly translatable: true;
+    };
+    readonly caption: _murumets_ee_entity.TextField & {
+        readonly translatable: true;
+    };
+}>;
+
+declare const QuoteBlock: BlockDefinition<{
+    readonly quote: _murumets_ee_entity.TextField & {
+        readonly required: true;
+        readonly translatable: true;
+    };
+    readonly attribution: _murumets_ee_entity.TextField & {
+        readonly translatable: true;
+    };
+}>;
+
+declare const RichTextBlock: BlockDefinition<{
+    readonly content: _murumets_ee_entity.RichTextField & {
+        readonly translatable: true;
+    };
+}>;
+
+declare const VideoBlock: BlockDefinition<{
+    readonly url: _murumets_ee_entity.TextField & {
+        readonly required: true;
+    };
+    readonly poster: _murumets_ee_entity.MediaField & {
+        readonly accept: ["image/*"];
+    };
+    readonly caption: _murumets_ee_entity.TextField & {
+        readonly translatable: true;
+    };
+}>;
+
+/**
+ * All common blocks shipped with the toolkit.
+ * Use as-is or pick individual blocks from the named exports.
+ *
+ * @example
+ * import { commonBlocks } from '@murumets-ee/content/blocks'
+ * const Page = defineEntity({
+ *   name: 'page',
+ *   fields: {
+ *     layout: field.blocks({ blocks: [...commonBlocks] }),
+ *   },
+ * })
+ */
+declare const commonBlocks: readonly [BlockDefinition<{
+    readonly content: _murumets_ee_entity.RichTextField & {
+        readonly translatable: true;
+    };
+}>, BlockDefinition<{
+    readonly image: _murumets_ee_entity.MediaField & {
+        readonly accept: ["image/*"];
+        readonly required: true;
+    };
+    readonly alt: _murumets_ee_entity.TextField & {
+        readonly translatable: true;
+    };
+    readonly caption: _murumets_ee_entity.TextField & {
+        readonly translatable: true;
+    };
+}>, BlockDefinition<{
+    readonly heading: _murumets_ee_entity.TextField & {
+        readonly required: true;
+        readonly translatable: true;
+    };
+    readonly subheading: _murumets_ee_entity.TextField & {
+        readonly translatable: true;
+    };
+    readonly background: _murumets_ee_entity.MediaField & {
+        readonly accept: ["image/*"];
+    };
+    readonly alignment: _murumets_ee_entity.SelectField & {
+        options: readonly ["left", "center", "right"];
+    } & Omit<Partial<_murumets_ee_entity.SelectField>, "options">;
+}>, BlockDefinition<{
+    readonly images: _murumets_ee_entity.ReferenceField & {
+        cardinality: "many";
+    } & Partial<Omit<_murumets_ee_entity.ReferenceField, "entity" | "cardinality">>;
+    readonly columns: _murumets_ee_entity.SelectField & {
+        options: readonly ["2", "3", "4"];
+    } & Omit<Partial<_murumets_ee_entity.SelectField>, "options">;
+}>, BlockDefinition<{
+    readonly heading: _murumets_ee_entity.TextField & {
+        readonly required: true;
+        readonly translatable: true;
+    };
+    readonly description: _murumets_ee_entity.TextField & {
+        readonly translatable: true;
+    };
+    readonly buttonText: _murumets_ee_entity.TextField & {
+        readonly required: true;
+        readonly translatable: true;
+    };
+    readonly buttonLink: _murumets_ee_entity.TextField & {
+        readonly required: true;
+    };
+}>, BlockDefinition<{
+    readonly url: _murumets_ee_entity.TextField & {
+        readonly required: true;
+    };
+    readonly poster: _murumets_ee_entity.MediaField & {
+        readonly accept: ["image/*"];
+    };
+    readonly caption: _murumets_ee_entity.TextField & {
+        readonly translatable: true;
+    };
+}>, BlockDefinition<{
+    readonly quote: _murumets_ee_entity.TextField & {
+        readonly required: true;
+        readonly translatable: true;
+    };
+    readonly attribution: _murumets_ee_entity.TextField & {
+        readonly translatable: true;
+    };
+}>, BlockDefinition<{
+    readonly code: _murumets_ee_entity.TextField & {
+        readonly required: true;
+    };
+    readonly language: _murumets_ee_entity.SelectField & {
+        options: readonly ["javascript", "typescript", "python", "html", "css", "json", "bash", "sql", "other"];
+    } & Omit<Partial<_murumets_ee_entity.SelectField>, "options">;
+}>];
+
+export { CTABlock, CodeBlock, GalleryBlock, HeroBlock, ImageBlock, QuoteBlock, RichTextBlock, VideoBlock, commonBlocks };

package/dist/blocks/index.js

@@ -0,0 +1 @@
+import{a as e}from"../chunk-CULYIGZI.js";import{field as d}from"@murumets-ee/entity";var r=e({slug:"code",label:"Code",fields:{code:d.text({required:!0}),language:d.select({options:["javascript","typescript","python","html","css","json","bash","sql","other"]})}});import{field as t}from"@murumets-ee/entity";var l=e({slug:"cta",label:"Call to Action",fields:{heading:t.text({required:!0,translatable:!0}),description:t.text({translatable:!0}),buttonText:t.text({required:!0,translatable:!0}),buttonLink:t.text({required:!0})}});import{field as u}from"@murumets-ee/entity";var i=e({slug:"gallery",label:"Gallery",fields:{images:u.reference({entity:"media",cardinality:"many"}),columns:u.select({options:["2","3","4"]})}});import{field as o}from"@murumets-ee/entity";var a=e({slug:"hero",label:"Hero Section",fields:{heading:o.text({required:!0,translatable:!0}),subheading:o.text({translatable:!0}),background:o.media({accept:["image/*"]}),alignment:o.select({options:["left","center","right"]})}});import{field as c}from"@murumets-ee/entity";var m=e({slug:"image",label:"Image",fields:{image:c.media({accept:["image/*"],required:!0}),alt:c.text({translatable:!0}),caption:c.text({translatable:!0})}});import{field as x}from"@murumets-ee/entity";var n=e({slug:"quote",label:"Quote",fields:{quote:x.text({required:!0,translatable:!0}),attribution:x.text({translatable:!0})}});import{field as k}from"@murumets-ee/entity";var f=e({slug:"richtext",label:"Rich Text",fields:{content:k.richtext({translatable:!0})}});import{field as s}from"@murumets-ee/entity";var p=e({slug:"video",label:"Video",fields:{url:s.text({required:!0}),poster:s.media({accept:["image/*"]}),caption:s.text({translatable:!0})}});var X=[f,m,a,i,l,p,n,r];export{l as CTABlock,r as CodeBlock,i as GalleryBlock,a as HeroBlock,m as ImageBlock,n as QuoteBlock,f as RichTextBlock,p as VideoBlock,X as commonBlocks};

package/dist/chunk-BVMZMEPV.js

@@ -0,0 +1 @@
+import{field as g}from"@murumets-ee/entity";var x={maxPerDoc:50,autosave:!1};function j(e){let t={...x,...e};return{name:"versionable",fields:{_version:g.number({required:!0,default:1,integer:!0}),_versionedAt:g.date()},hooks:{beforeCreate:async s=>(s._version=1,s._versionedAt=new Date,s),beforeUpdate:async(s,f)=>(f._versionedAt=new Date,f)},_versionableOptions:t}}function F(e){return e?e.find(n=>n.name==="versionable")?._versionableOptions??null:null}function h(e){return e.match(/\S+|\s+/g)??[]}function b(e,t){if(e===t)return e?[{type:"equal",value:e}]:[];if(!e)return[{type:"add",value:t}];if(!t)return[{type:"remove",value:e}];let n=h(e),s=h(t),f=n.length,r=s.length,o=Array.from({length:f+1},()=>new Array(r+1).fill(0));for(let c=1;c<=f;c++)for(let u=1;u<=r;u++)n[c-1]===s[u-1]?o[c][u]=o[c-1][u-1]+1:o[c][u]=Math.max(o[c-1][u],o[c][u-1]);let p=[],i=f,l=r,d=[];for(;i>0||l>0;)i>0&&l>0&&n[i-1]===s[l-1]?(d.push({type:"equal",value:n[i-1]}),i--,l--):l>0&&(i===0||o[i][l-1]>=o[i-1][l])?(d.push({type:"add",value:s[l-1]}),l--):(d.push({type:"remove",value:n[i-1]}),i--);d.reverse();for(let c of d){let u=p[p.length-1];u&&u.type===c.type?u.value+=c.value:p.push({...c})}return p}function m(e){return e.replace(/<[^>]*>/g," ").replace(/\s+/g," ").trim()}function a(e){return e==null?"":e instanceof Date?e.toISOString():typeof e=="object"?JSON.stringify(e):String(e)}function D(e,t,n,s){if(JSON.stringify(t)===JSON.stringify(n))return null;switch(s?.type??O(t,n)){case"text":case"slug":{let r=b(a(t),a(n));return{field:e,type:"text",from:t,to:n,segments:r}}case"richtext":{let r=b(m(a(t)),m(a(n)));return{field:e,type:"richtext",from:t,to:n,segments:r}}case"number":return{field:e,type:"number",from:t,to:n};case"boolean":return{field:e,type:"boolean",from:t,to:n};case"date":return{field:e,type:"date",from:t,to:n};case"select":return{field:e,type:"select",from:t,to:n};case"media":return{field:e,type:"media",from:t,to:n};case"json":return{field:e,type:"json",from:t,to:n};case"blocks":return{field:e,type:"blocks",from:t,to:n};default:return{field:e,type:"unknown",from:t,to:n}}}function I(e,t,n){let s=new Set([...Object.keys(e),...Object.keys(t)]),f=[];for(let r of s){if(r==="id"||r==="createdAt"||r==="updatedAt")continue;let o=D(r,e[r],t[r],n?.[r]);o&&f.push(o)}return f}function O(e,t){let n=e??t;return typeof n=="number"?"number":typeof n=="boolean"?"boolean":n instanceof Date?"date":typeof n=="string"?/^\d{4}-\d{2}-\d{2}/.test(n)?"date":"text":Array.isArray(n)?n.length>0&&typeof n[0]=="object"&&n[0]!==null&&"_block"in n[0]?"blocks":"json":typeof n=="object"?"json":"unknown"}function v(e,t){if(typeof e=="string"||typeof t=="string")return b(a(e),a(t))}function _(e){return typeof e=="object"&&e!==null&&"_block"in e&&"_id"in e&&typeof e._block=="string"&&typeof e._id=="string"}function B(e,t){let n=new Set([...Object.keys(e),...Object.keys(t)]),s=[];for(let f of n){if(f==="_block"||f==="_id")continue;let r=e[f],o=t[f];JSON.stringify(r)!==JSON.stringify(o)&&s.push({field:f,from:r,to:o,segments:v(r,o)})}return s}function E(e,t){let n=e.filter(_),s=t.filter(_),f=new Map,r=new Map;for(let i=0;i<n.length;i++)f.set(n[i]._id,{block:n[i],index:i});for(let i=0;i<s.length;i++)r.set(s[i]._id,{block:s[i],index:i});let o=[],p=new Set;for(let[i,{block:l,index:d}]of r){p.add(i);let c=f.get(i);if(!c){o.push({blockId:i,blockType:l._block,status:"added",toIndex:d});continue}let u=c.block,y=c.index,k=B(u,l),w=y!==d;k.length===0&&!w?o.push({blockId:i,blockType:l._block,status:"unchanged",fromIndex:y,toIndex:d}):k.length>0?o.push({blockId:i,blockType:l._block,status:"changed",fromIndex:y,toIndex:d,propDiffs:k}):o.push({blockId:i,blockType:l._block,status:"moved",fromIndex:y,toIndex:d})}for(let[i,{block:l,index:d}]of f)p.has(i)||o.push({blockId:i,blockType:l._block,status:"removed",fromIndex:d});return o}export{j as a,F as b,b as c,D as d,I as e,v as f,E as g};

package/dist/chunk-CULYIGZI.js

@@ -0,0 +1 @@
+function e(l){if(!l.slug||!l.slug.match(/^[a-z][a-z0-9-]*$/))throw new Error(`Block slug must be lowercase alphanumeric with hyphens, got: "${l.slug}"`);if(!l.label)throw new Error(`Block label is required for slug: "${l.slug}"`);if(!l.fields||Object.keys(l.fields).length===0)throw new Error(`Block "${l.slug}" must have at least one field`);return{slug:l.slug,label:l.label,fields:l.fields}}export{e as a};

package/dist/client.d.ts

@@ -0,0 +1,215 @@
+import { Logger } from '@murumets-ee/core';
+import { Entity, FieldToTS, FieldConfig } from '@murumets-ee/entity';
+import { FindManyOptions } from '@murumets-ee/entity/admin';
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import { F as FieldDiff } from './types-Cr0ifLn_.js';
+import { V as VersionEntry, D as DraftEntry, T as TranslationStatus, a as TranslationReport, L as LocalePublishStatus } from './types-BYeiE1ie.js';
+
+/**
+ * ContentClient — wraps AdminClient with version history and translation status.
+ *
+ * Usage:
+ *   import { createContentClient } from '@murumets-ee/content/client'
+ *   const pages = createContentClient(Page)
+ *   await pages.create({ title: 'Hello', layout: [...] })
+ */
+
+/** Value type that any entity field can hold */
+type EntityFieldValue = FieldToTS<FieldConfig> | null | undefined;
+interface ContentClientConfig {
+    entity: Entity;
+    db: PostgresJsDatabase;
+    logger?: Logger;
+}
+declare class ContentClient {
+    private entity;
+    private db;
+    private logger?;
+    private admin;
+    private versionableOptions;
+    constructor(config: ContentClientConfig);
+    private getAdmin;
+    create(data: Record<string, EntityFieldValue>): Promise<{
+        id: string;
+    } & {} & {
+        [x: string]: string | number | boolean | Date | Record<string, unknown> | Record<string, unknown>[] | {
+            [key: string]: unknown;
+            _block: string;
+            _id: string;
+        }[] | null | undefined;
+    }>;
+    findById(id: string, options?: {
+        locale?: string;
+    }): Promise<({
+        id: string;
+    } & {} & {
+        [x: string]: string | number | boolean | Date | Record<string, unknown> | Record<string, unknown>[] | {
+            [key: string]: unknown;
+            _block: string;
+            _id: string;
+        }[] | null | undefined;
+    }) | null>;
+    findMany(options?: FindManyOptions): Promise<({
+        id: string;
+    } & {} & {
+        [x: string]: string | number | boolean | Date | Record<string, unknown> | Record<string, unknown>[] | {
+            [key: string]: unknown;
+            _block: string;
+            _id: string;
+        }[] | null | undefined;
+    })[]>;
+    update(id: string, data: Record<string, EntityFieldValue>): Promise<{
+        id: string;
+    } & {} & {
+        [x: string]: string | number | boolean | Date | Record<string, unknown> | Record<string, unknown>[] | {
+            [key: string]: unknown;
+            _block: string;
+            _id: string;
+        }[] | null | undefined;
+    }>;
+    delete(id: string): Promise<void>;
+    saveTranslation(entityId: string, locale: string, translations: Record<string, unknown>): Promise<void>;
+    deleteTranslation(entityId: string, locale?: string): Promise<void>;
+    /**
+     * Copy layout from one locale to another (for localized: true blocks).
+     */
+    copyLayout(entityId: string, options: {
+        from: string;
+        to: string | string[];
+    }): Promise<void>;
+    /**
+     * List versions for an entity (newest first), filtered by locale.
+     * Uses '_' as the locale value for default-locale snapshots.
+     */
+    getVersions(entityId: string, options?: {
+        limit?: number;
+        offset?: number;
+        locale?: string;
+    }): Promise<VersionEntry[]>;
+    /**
+     * Get a specific version snapshot.
+     */
+    getVersion(entityId: string, version: number, locale?: string): Promise<VersionEntry | null>;
+    /**
+     * Compare two versions and return field-level diff.
+     *
+     * Returns structured diffs with word-level segments for text fields
+     * and structural block diffs for blocks fields.
+     */
+    compareVersions(entityId: string, v1: number, v2: number, locale?: string): Promise<{
+        diffs: FieldDiff[];
+        fromVersion: VersionEntry;
+        toVersion: VersionEntry;
+    } | null>;
+    /**
+     * Compare the current draft with the live entity (or a specific version).
+     * Returns field-level diffs between the current published data and the draft.
+     */
+    compareDraftWithCurrent(entityId: string, locale?: string): Promise<{
+        diffs: FieldDiff[];
+        current: Record<string, unknown>;
+        draft: DraftEntry;
+    } | null>;
+    /**
+     * Restore an entity to a previous version.
+     */
+    restoreVersion(entityId: string, version: number): Promise<{
+        id: string;
+    } & {} & {
+        [x: string]: string | number | boolean | Date | Record<string, unknown> | Record<string, unknown>[] | {
+            [key: string]: unknown;
+            _block: string;
+            _id: string;
+        }[] | null | undefined;
+    }>;
+    /**
+     * Enforce maxPerDoc retention by deleting oldest versions for a locale.
+     */
+    pruneVersions(entityId: string, locale?: string): Promise<void>;
+    /**
+     * Get translation status for an entity — per-locale completion report.
+     */
+    getTranslationStatus(entityId: string): Promise<TranslationStatus>;
+    /**
+     * Get translation status for multiple entities in a single query.
+     * Returns a map of entityId → TranslationStatus (O(1) DB roundtrips).
+     */
+    getTranslationStatusBatch(entityIds: string[]): Promise<Map<string, TranslationStatus>>;
+    /**
+     * Get translation report across all entities of this type.
+     */
+    getTranslationReport(options?: {
+        locale?: string;
+    }): Promise<TranslationReport>;
+    /**
+     * Get per-locale publish status for an entity.
+     * Returns status for all non-default locales that have explicit overrides.
+     * Missing locale = inherits base entity status.
+     */
+    getLocaleStatus(entityId: string): Promise<LocalePublishStatus[]>;
+    /**
+     * Set per-locale publish status. Upserts into locale_status table.
+     * When locale === defaultLocale, updates the base entity status instead.
+     */
+    setLocaleStatus(entityId: string, locale: string, status: 'draft' | 'published'): Promise<void>;
+    /**
+     * Get per-locale publish status for multiple entities in a single query.
+     * Returns a map of entityId → locale → LocalePublishStatus.
+     */
+    getLocaleStatusBatch(entityIds: string[]): Promise<Map<string, Record<string, LocalePublishStatus>>>;
+    /**
+     * Save (upsert) a draft for an entity+locale.
+     * One draft per entity+locale — overwrites any existing draft.
+     */
+    saveDraft(entityId: string, data: Record<string, unknown>, locale?: string, user?: {
+        id: string;
+        name?: string;
+    }): Promise<DraftEntry>;
+    /**
+     * Get the draft for an entity+locale, or null if none exists.
+     */
+    getDraft(entityId: string, locale?: string): Promise<DraftEntry | null>;
+    /**
+     * Delete (discard) a draft for an entity+locale.
+     */
+    deleteDraft(entityId: string, locale?: string): Promise<boolean>;
+    /**
+     * Publish a draft: apply draft data to the live entity, then delete the draft.
+     * Runs in a transaction to ensure atomicity.
+     */
+    publishDraft(entityId: string, locale?: string, user?: {
+        id: string;
+        name?: string;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Quick existence check for list badges — does a draft exist?
+     */
+    hasDraft(entityId: string, locale?: string): Promise<boolean>;
+    /**
+     * Check draft existence for multiple entities in one query.
+     * Returns a set of entity IDs that have drafts.
+     */
+    hasDraftBatch(entityIds: string[], locale?: string): Promise<Set<string>>;
+    /**
+     * Create a version snapshot for an entity after an external update.
+     * Use this when the update was performed by AdminClient directly
+     * (e.g., the admin API handler) rather than through ContentClient.update().
+     *
+     * @param locale - The locale being edited. Use undefined or '_' for the default locale.
+     * @param user - The user who made the change (id + name for display).
+     */
+    createVersionSnapshot(entityId: string, currentData: Record<string, unknown>, previousData?: Record<string, unknown> | null, locale?: string, user?: {
+        id: string;
+        name?: string;
+    }): Promise<void>;
+    private saveVersionSnapshot;
+    private toDraftEntry;
+    private calculateDelta;
+}
+/**
+ * Factory — creates a ContentClient for an entity.
+ * Must be called after createApp().
+ */
+declare function createContentClient(entity: Entity): Promise<ContentClient>;
+
+export { ContentClient, type ContentClientConfig, createContentClient };

package/dist/client.js

@@ -0,0 +1 @@
+import{b as v,e as p,g as b}from"./chunk-BVMZMEPV.js";import"server-only";var R=class{entity;db;logger;admin=null;versionableOptions;constructor(t){this.entity=t.entity,this.db=t.db,this.logger=t.logger,this.versionableOptions=v(t.entity.behaviors)}async getAdmin(){if(!this.admin){let{AdminClient:t}=await import("@murumets-ee/entity/admin");this.admin=new t({entity:this.entity,db:this.db,logger:this.logger})}return this.admin}async create(t){let i=await(await this.getAdmin()).create(t);return this.versionableOptions&&await this.saveVersionSnapshot(i.id,i,null,!1),i}async findById(t,e){return(await this.getAdmin()).findById(t,e)}async findMany(t){return(await this.getAdmin()).findMany(t)}async update(t,e){let i=await this.getAdmin(),n=null;this.versionableOptions&&(n=await i.findById(t));let o=await i.update(t,e);if(this.versionableOptions&&n){let s=this.calculateDelta(n,o),r=await this.saveVersionSnapshot(t,o,s,!1);if(r!==void 0){let{schemaRegistry:a}=await import("@murumets-ee/db"),{eq:c}=await import("drizzle-orm"),d=a.get(this.entity.name);d&&(await this.db.update(d).set({_version:r}).where(c(d.id,t)),o._version=r)}await this.pruneVersions(t)}return o}async delete(t){return(await this.getAdmin()).delete(t)}async saveTranslation(t,e,i){return(await this.getAdmin()).saveTranslation(t,e,i)}async deleteTranslation(t,e){return(await this.getAdmin()).deleteTranslation(t,e)}async copyLayout(t,e){let{schemaRegistry:i}=await import("@murumets-ee/db"),{eq:n,and:o}=await import("drizzle-orm"),s=i.get(`${this.entity.name}_layout`);if(!s)return;let r=Array.isArray(e.to)?e.to:[e.to],a=await this.db.select().from(s).where(o(n(s.entityId,t),n(s.locale,e.from))).orderBy(s.sortOrder);if(a.length!==0){for(let c of r){await this.db.delete(s).where(o(n(s.entityId,t),n(s.locale,c)));for(let d of a)await this.db.insert(s).values({entityId:d.entityId,fieldName:d.fieldName,blockType:d.blockType,sortOrder:d.sortOrder,data:d.data,locale:c})}this.logger?.debug({entityId:t,from:e.from,to:r},"Layout copied between locales")}}async getVersions(t,e){let{schemaRegistry:i}=await import("@murumets-ee/db"),{eq:n,and:o,desc:s}=await import("drizzle-orm"),r=i.get(`${this.entity.name}_versions`);if(!r)return[];let a=e?.locale??"_",c=this.db.select().from(r).where(o(n(r.entityId,t),n(r.locale,a))).orderBy(s(r.version)).$dynamic();return e?.limit&&(c=c.limit(e.limit)),e?.offset&&(c=c.offset(e.offset)),c}async getVersion(t,e,i="_"){let{schemaRegistry:n}=await import("@murumets-ee/db"),{eq:o,and:s}=await import("drizzle-orm"),r=n.get(`${this.entity.name}_versions`);return r?(await this.db.select().from(r).where(s(o(r.entityId,t),o(r.version,e),o(r.locale,i))).limit(1))[0]??null:null}async compareVersions(t,e,i,n="_"){let[o,s]=await Promise.all([this.getVersion(t,e,n),this.getVersion(t,i,n)]);if(!o||!s)return null;let r=o.data,a=s.data,c=this.entity.allFields,d=p(r,a,c);for(let l of d)l.type==="blocks"&&Array.isArray(l.from)&&Array.isArray(l.to)&&(l.blockDiffs=b(l.from,l.to));return{diffs:d,fromVersion:o,toVersion:s}}async compareDraftWithCurrent(t,e="_"){let i=await this.getDraft(t,e);if(!i)return null;let n=await this.getAdmin(),{getContentConfig:o}=await import("./plugin.js"),r=o().defaultLocale,a=e==="_"?{defaultLocale:r}:{locale:e,defaultLocale:r},c=await n.findById(t,a);if(!c)return null;let d=this.entity.allFields,l={};for(let f of Object.keys(i.data))l[f]=c[f];let u=p(l,i.data,d);for(let f of u)f.type==="blocks"&&Array.isArray(f.from)&&Array.isArray(f.to)&&(f.blockDiffs=b(f.from,f.to));return{diffs:u,current:c,draft:i}}async restoreVersion(t,e){let i=await this.getVersion(t,e);if(!i)throw new Error(`Version ${e} not found for entity ${t}`);let n=i.data,{id:o,createdAt:s,createdBy:r,_version:a,_versionedAt:c,...d}=n;return(await this.getAdmin()).update(t,d)}async pruneVersions(t,e="_"){if(!this.versionableOptions)return;let{schemaRegistry:i}=await import("@murumets-ee/db"),{eq:n,and:o,desc:s,sql:r}=await import("drizzle-orm"),a=i.get(`${this.entity.name}_versions`);if(!a)return;let c=this.versionableOptions.maxPerDoc,d=await this.db.select({id:a.id}).from(a).where(o(n(a.entityId,t),n(a.locale,e))).orderBy(s(a.version)).limit(c);if(d.length<c)return;let l=d.map(u=>u.id);await this.db.delete(a).where(r`${a.entityId} = ${t} AND ${a.locale} = ${e} AND ${a.id} NOT IN (${r.join(l.map(u=>r`${u}`),r`, `)})`)}async getTranslationStatus(t){let{getContentConfig:e}=await import("./plugin.js"),i=e(),n=Object.entries(this.entity.allFields).filter(([l,u])=>u.translatable).map(([l])=>l);if(n.length===0)return{};let{schemaRegistry:o}=await import("@murumets-ee/db"),{eq:s}=await import("drizzle-orm"),r=o.get(`${this.entity.name}_translations`);if(!r)return{};let a=await this.db.select().from(r).where(s(r.entityId,t)),c=new Map;for(let l of a){let u=l,f={};for(let g of n)f[g]=u[g];c.set(u.locale,f)}let d={};for(let l of i.locales){if(l.code===i.defaultLocale)continue;let u=c.get(l.code)??{},f=[];for(let m of n)(u[m]===void 0||u[m]===null)&&f.push(m);let g=n.length-f.length;d[l.code]={complete:f.length===0,total:n.length,translated:g,missing:f}}return d}async getTranslationStatusBatch(t){let e=new Map;if(t.length===0)return e;let{getContentConfig:i}=await import("./plugin.js"),n=i(),o=Object.entries(this.entity.allFields).filter(([l,u])=>u.translatable).map(([l])=>l);if(o.length===0)return e;let{schemaRegistry:s}=await import("@murumets-ee/db"),{inArray:r}=await import("drizzle-orm"),a=s.get(`${this.entity.name}_translations`);if(!a)return e;let c=await this.db.select().from(a).where(r(a.entityId,t)),d=new Map;for(let l of c){let u=l,f=u.entityId,g=u.locale,m={};for(let h of o)m[h]=u[h];d.has(f)||d.set(f,new Map),d.get(f).set(g,m)}for(let l of t){let u=d.get(l),f={};for(let g of n.locales){if(g.code===n.defaultLocale)continue;let m=u?.get(g.code)??{},h=[];for(let w of o)(m[w]===void 0||m[w]===null)&&h.push(w);let A=o.length-h.length;f[g.code]={complete:h.length===0,total:o.length,translated:A,missing:h}}e.set(l,f)}return e}async getTranslationReport(t){let{getContentConfig:e}=await import("./plugin.js"),i=e(),n=t?.locale??i.locales.find(d=>d.code!==i.defaultLocale)?.code;if(!n)return{total:0,complete:0,partial:0,missing:0};let s=await(await this.getAdmin()).findMany(),r=0,a=0,c=0;for(let d of s){let u=(await this.getTranslationStatus(d.id))[n];!u||u.translated===0?c++:u.complete?r++:a++}return{total:s.length,complete:r,partial:a,missing:c}}async getLocaleStatus(t){let{schemaRegistry:e}=await import("@murumets-ee/db"),{eq:i}=await import("drizzle-orm"),n=e.get(`${this.entity.name}_locale_status`);return n?(await this.db.select().from(n).where(i(n.entityId,t))).map(s=>({locale:s.locale,status:s.status,publishedAt:s.publishedAt??null})):[]}async setLocaleStatus(t,e,i){let{getContentConfig:n}=await import("./plugin.js"),o=n();if(e===o.defaultLocale){let u=await this.getAdmin(),f={status:i};i==="published"&&(f.publishedAt=new Date),await u.update(t,f);return}let{schemaRegistry:s}=await import("@murumets-ee/db"),{eq:r,and:a}=await import("drizzle-orm"),c=s.get(`${this.entity.name}_locale_status`);if(!c)return;let d=i==="published"?new Date:null,[l]=await this.db.select({id:c.id}).from(c).where(a(r(c.entityId,t),r(c.locale,e))).limit(1);l?await this.db.update(c).set({status:i,publishedAt:d}).where(r(c.id,l.id)):await this.db.insert(c).values({entityId:t,locale:e,status:i,publishedAt:d})}async getLocaleStatusBatch(t){let e=new Map;if(t.length===0)return e;let{schemaRegistry:i}=await import("@murumets-ee/db"),{inArray:n}=await import("drizzle-orm"),o=i.get(`${this.entity.name}_locale_status`);if(!o)return e;let s=await this.db.select().from(o).where(n(o.entityId,t));for(let r of s){let a=r.entityId,c=r.locale;e.has(a)||e.set(a,{}),e.get(a)[c]={locale:c,status:r.status,publishedAt:r.publishedAt??null}}return e}async saveDraft(t,e,i="_",n){let{schemaRegistry:o}=await import("@murumets-ee/db"),{eq:s,and:r}=await import("drizzle-orm"),a=o.get(`${this.entity.name}_drafts`);if(!a)throw new Error(`Drafts table not found for entity "${this.entity.name}". Is the content plugin initialized?`);let c=new Date,d=n?.id??"",l=n?.name??null,[u]=await this.db.select().from(a).where(r(s(a.entityId,t),s(a.locale,i))).limit(1);if(u){let[g]=await this.db.update(a).set({data:e,updatedAt:c}).where(s(a.id,u.id)).returning();return this.toDraftEntry(g)}let[f]=await this.db.insert(a).values({entityId:t,locale:i,data:e,createdBy:d,createdByName:l,createdAt:c,updatedAt:c}).returning();return this.toDraftEntry(f)}async getDraft(t,e="_"){let{schemaRegistry:i}=await import("@murumets-ee/db"),{eq:n,and:o}=await import("drizzle-orm"),s=i.get(`${this.entity.name}_drafts`);if(!s)return null;let[r]=await this.db.select().from(s).where(o(n(s.entityId,t),n(s.locale,e))).limit(1);return r?this.toDraftEntry(r):null}async deleteDraft(t,e="_"){let{schemaRegistry:i}=await import("@murumets-ee/db"),{eq:n,and:o}=await import("drizzle-orm"),s=i.get(`${this.entity.name}_drafts`);return s?(await this.db.delete(s).where(o(n(s.entityId,t),n(s.locale,e))).returning({id:s.id})).length>0:!1}async publishDraft(t,e="_",i){let n=await this.getDraft(t,e);if(!n)throw new Error(`No draft found for entity ${t} locale ${e}`);let o=await this.getAdmin(),s=null;this.versionableOptions&&(s=await o.findById(t));let r=n.data,{id:a,createdAt:c,createdBy:d,_version:l,_versionedAt:u,...f}=r,g=await o.update(t,f);return await this.deleteDraft(t,e),this.versionableOptions&&await this.createVersionSnapshot(t,g,s,e,i),g}async hasDraft(t,e="_"){let{schemaRegistry:i}=await import("@murumets-ee/db"),{eq:n,and:o}=await import("drizzle-orm"),s=i.get(`${this.entity.name}_drafts`);if(!s)return!1;let[r]=await this.db.select({id:s.id}).from(s).where(o(n(s.entityId,t),n(s.locale,e))).limit(1);return!!r}async hasDraftBatch(t,e="_"){let i=new Set;if(t.length===0)return i;let{schemaRegistry:n}=await import("@murumets-ee/db"),{inArray:o,eq:s,and:r}=await import("drizzle-orm"),a=n.get(`${this.entity.name}_drafts`);if(!a)return i;let c=await this.db.select({entityId:a.entityId}).from(a).where(r(o(a.entityId,t),s(a.locale,e)));for(let d of c)i.add(d.entityId);return i}async createVersionSnapshot(t,e,i,n,o){if(!this.versionableOptions)return;let s=n??"_",r=i?this.calculateDelta(i,e):null,a=await this.saveVersionSnapshot(t,e,r,!1,s,o);if(a!==void 0&&s==="_"){let{schemaRegistry:c}=await import("@murumets-ee/db"),{eq:d}=await import("drizzle-orm"),l=c.get(this.entity.name);l&&await this.db.update(l).set({_version:a}).where(d(l.id,t))}await this.pruneVersions(t,s)}async saveVersionSnapshot(t,e,i,n,o="_",s){let{schemaRegistry:r}=await import("@murumets-ee/db"),{eq:a,and:c,sql:d}=await import("drizzle-orm"),l=r.get(`${this.entity.name}_versions`);if(!l)return;let[u]=await this.db.select({maxVersion:d`coalesce(max(${l.version}), 0)`}).from(l).where(c(a(l.entityId,t),a(l.locale,o))),f=(u?.maxVersion??0)+1,g=e.status??null;if(n){let[m]=await this.db.select().from(l).where(c(a(l.entityId,t),a(l.isAutosave,!0),a(l.version,f),a(l.locale,o))).limit(1);if(m)return await this.db.update(l).set({data:e,delta:i,status:g,createdAt:new Date}).where(a(l.id,m.id)),f}return await this.db.insert(l).values({entityId:t,version:f,locale:o,data:e,delta:i,status:g,createdBy:s?.id??e.updatedBy??e.createdBy??null,createdByName:s?.name??null,isAutosave:n}),f}toDraftEntry(t){return{id:t.id,entityId:t.entityId,locale:t.locale,data:t.data,createdBy:t.createdBy,createdByName:t.createdByName??null,createdAt:t.createdAt,updatedAt:t.updatedAt}}calculateDelta(t,e){let i={};for(let n of Object.keys(e))n==="id"||n.startsWith("_")||JSON.stringify(t[n])!==JSON.stringify(e[n])&&(i[n]=e[n]);return i}};async function T(y){let{getApp:t}=await import("@murumets-ee/core"),e=t();return new R({entity:y,db:e.db.readWrite,logger:e.logger.child({content:y.name})})}export{R as ContentClient,T as createContentClient};

package/dist/drafts-2ZRAHAUK.js

@@ -0,0 +1 @@
+import{jsonb as o,pgTable as u,timestamp as a,unique as r,uuid as n,varchar as t}from"drizzle-orm/pg-core";function m(l){let d=`${l.name}_drafts`;return u(d,{id:n("id").primaryKey().defaultRandom(),entityId:n("entity_id").notNull(),locale:t("locale",{length:10}).notNull().default("_"),data:o("data").notNull(),createdBy:t("created_by",{length:255}).notNull(),createdByName:t("created_by_name",{length:255}),createdAt:a("created_at",{withTimezone:!0}).notNull().defaultNow(),updatedAt:a("updated_at",{withTimezone:!0}).notNull().defaultNow()},e=>({uniqueEntityLocale:r().on(e.entityId,e.locale)}))}export{m as generateDraftsSchema};

package/dist/index.d.ts

@@ -0,0 +1,142 @@
+import { Behavior, NumberField, DateField, SelectField, TextField, FieldConfig } from '@murumets-ee/entity';
+import { b as VersionableOptions, B as BlockDefinition } from './types-BYeiE1ie.js';
+export { C as ContentConfig, D as DraftEntry, I as InferBlockData, c as InferBlocksUnion, d as LocaleConfig, e as LockInfo, f as TranslationFieldStatus, a as TranslationReport, T as TranslationStatus, V as VersionEntry } from './types-BYeiE1ie.js';
+import { B as BlockDiffEntry, F as FieldDiff, D as DiffSegment } from './types-Cr0ifLn_.js';
+export { a as BlockDiffStatus, P as PropDiff } from './types-Cr0ifLn_.js';
+
+/**
+ * Versionable behavior — full version history with snapshots.
+ *
+ * Extends the concept of revisionable() (which only tracks a counter)
+ * with actual version snapshots stored in {entity}_versions table.
+ *
+ * The behavior itself adds fields + hooks for version tracking.
+ * Actual snapshot persistence happens in ContentClient (which has DB access).
+ *
+ * Options:
+ * - maxPerDoc: Maximum versions kept per document (default: 50)
+ * - autosave: Enable smart autosave (default: false)
+ */
+
+type VersionableFields = {
+    _version: NumberField & {
+        required: true;
+    };
+    _versionedAt: DateField;
+};
+declare function versionable(options?: VersionableOptions): Behavior<VersionableFields>;
+/**
+ * Extract versionable options from an entity's behaviors
+ */
+declare function getVersionableOptions(behaviors?: Behavior[]): Required<VersionableOptions> | null;
+
+/**
+ * Workflowable behavior — editorial workflow with approval gates.
+ *
+ * Adds workflow status tracking fields to an entity. Works alongside
+ * `publishable()` — the workflow status tracks the editorial pipeline,
+ * while publishable's `status` remains the public-facing state.
+ *
+ * Key invariant: `status` can only transition to 'published' when
+ * `_workflowStatus === 'approved'` (unless the user has direct `publish`
+ * permission, which bypasses the workflow).
+ *
+ * Workflow states:
+ * - draft → in_review (submit for review, requires 'update')
+ * - in_review → approved (approve, requires 'publish')
+ * - in_review → rejected (reject with note, requires 'publish')
+ * - approved → published (publish, requires 'publish')
+ * - rejected → in_review (resubmit, requires 'update')
+ * - published → draft (unpublish, requires 'publish')
+ */
+
+declare const WORKFLOW_STATES: readonly ["draft", "in_review", "approved", "rejected", "published"];
+type WorkflowState = (typeof WORKFLOW_STATES)[number];
+type WorkflowableFields = {
+    _workflowStatus: SelectField & {
+        required: true;
+    };
+    _workflowAssignee: TextField;
+    _workflowNote: TextField;
+    _workflowUpdatedAt: DateField;
+};
+declare function workflowable(): Behavior<WorkflowableFields>;
+
+/**
+ * Block definition API
+ *
+ * defineBlock() creates a reusable content block with typed fields.
+ * Uses `const F` generic to preserve literal field types for inference.
+ *
+ * Blocks are NOT entities — they lack independent identity, CRUD, and access control.
+ * They exist only as embedded data within a parent entity's blocks field.
+ *
+ * @example
+ * const HeroBlock = defineBlock({
+ *   slug: 'hero',
+ *   label: 'Hero Section',
+ *   fields: {
+ *     heading: field.text({ required: true, translatable: true }),
+ *     background: field.media({ accept: ['image/*'] }),
+ *   },
+ * })
+ */
+
+declare function defineBlock<const F extends Record<string, FieldConfig>>(definition: {
+    slug: string;
+    label: string;
+    fields: F;
+}): BlockDefinition<F>;
+
+/**
+ * Structural diff for Puck block arrays.
+ *
+ * Blocks are identified by `_id`. The algorithm detects:
+ * - Added blocks (new _id in target)
+ * - Removed blocks (missing _id in target)
+ * - Moved blocks (same _id, different position)
+ * - Changed blocks (same _id, different prop values)
+ * - Unchanged blocks
+ */
+
+/**
+ * Compute structural diff between two block arrays.
+ *
+ * Each block is identified by its `_id` field. Position changes,
+ * additions, removals, and prop-level changes are all detected.
+ */
+declare function diffBlocks(fromBlocks: unknown[], toBlocks: unknown[]): BlockDiffEntry[];
+
+/**
+ * Field-level diff — dispatches to the appropriate diff strategy per field type.
+ */
+
+/**
+ * Compute diff for a single field, using the field's type to determine
+ * the best diff strategy.
+ */
+declare function diffField(fieldName: string, from: unknown, to: unknown, fieldConfig?: FieldConfig): FieldDiff | null;
+/**
+ * Diff all fields between two version snapshots.
+ * Pass fieldConfigs to get type-aware diffs; without them, types are inferred.
+ */
+declare function diffFields(from: Record<string, unknown>, to: Record<string, unknown>, fieldConfigs?: Record<string, FieldConfig>): FieldDiff[];
+/** Diff two string values and return segments (used by block-diff for string props). */
+declare function diffStringValues(from: unknown, to: unknown): DiffSegment[] | undefined;
+
+/**
+ * Word-level text diff using a simplified Myers algorithm.
+ *
+ * Splits text into words (preserving whitespace), computes the longest common
+ * subsequence, and returns an array of diff segments.
+ */
+
+/**
+ * Compute word-level diff between two strings.
+ *
+ * Uses a simple LCS (dynamic programming) approach which is fine for
+ * the text sizes we deal with (entity field values, not source code).
+ */
+declare function diffText(from: string, to: string): DiffSegment[];
+
+export { BlockDefinition, BlockDiffEntry, DiffSegment, FieldDiff, VersionableOptions, WORKFLOW_STATES, type WorkflowState, type WorkflowableFields, defineBlock, diffBlocks, diffField, diffFields, diffStringValues, diffText, getVersionableOptions, versionable, workflowable };

package/dist/index.js

@@ -0,0 +1 @@
+import{a as r,b as f,c as l,d as i,e as a,f as n,g as s}from"./chunk-BVMZMEPV.js";import{a as d}from"./chunk-CULYIGZI.js";import{field as e}from"@murumets-ee/entity";var t=["draft","in_review","approved","rejected","published"];function w(){return{name:"workflowable",fields:{_workflowStatus:e.select({options:t,default:"draft",indexed:!0,required:!0}),_workflowAssignee:e.text({required:!1}),_workflowNote:e.text({required:!1}),_workflowUpdatedAt:e.date()},hooks:{beforeCreate:async o=>(o._workflowStatus="draft",o._workflowUpdatedAt=new Date,o)}}}export{t as WORKFLOW_STATES,d as defineBlock,s as diffBlocks,i as diffField,a as diffFields,n as diffStringValues,l as diffText,f as getVersionableOptions,r as versionable,w as workflowable};

package/dist/locale-status-B7B3WFXF.js

@@ -0,0 +1 @@
+import{pgTable as i,timestamp as u,unique as o,uuid as e,varchar as a}from"drizzle-orm/pg-core";function m(l){let n=`${l.name}_locale_status`;return i(n,{id:e("id").primaryKey().defaultRandom(),entityId:e("entity_id").notNull(),locale:a("locale",{length:10}).notNull(),status:a("status",{length:20}).notNull().default("draft"),publishedAt:u("published_at",{withTimezone:!0})},t=>({uniqueEntityLocale:o().on(t.entityId,t.locale)}))}export{m as generateLocaleStatusSchema};

package/dist/lock-service.d.ts

@@ -0,0 +1,61 @@
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import { e as LockInfo } from './types-BYeiE1ie.js';
+import '@murumets-ee/entity';
+
+/**
+ * Content lock service — pessimistic locking for entity editing.
+ *
+ * Prevents concurrent edit conflicts by allowing only one editor at a time
+ * per entity+locale combination. Locks expire after 5 minutes and must
+ * be renewed via heartbeat.
+ */
+
+interface LockServiceConfig {
+    db: PostgresJsDatabase;
+}
+declare class LockService {
+    private db;
+    constructor(config: LockServiceConfig);
+    private getTable;
+    /**
+     * Acquire a lock on an entity+locale.
+     *
+     * - Deletes expired locks first
+     * - Attempts INSERT; on conflict checks if same user (re-entrant → renew)
+     * - Returns { acquired: true } or { acquired: false, lock: LockInfo }
+     */
+    acquireLock(entityType: string, entityId: string, locale: string, user: {
+        id: string;
+        name?: string;
+    }): Promise<{
+        acquired: true;
+    } | {
+        acquired: false;
+        lock: LockInfo;
+    }>;
+    /**
+     * Renew an existing lock (heartbeat).
+     * Only succeeds if the caller holds the lock and it hasn't expired.
+     */
+    renewLock(entityType: string, entityId: string, locale: string, userId: string): Promise<boolean>;
+    /**
+     * Release a lock. Only the lock holder can release their own lock.
+     */
+    releaseLock(entityType: string, entityId: string, locale: string, userId: string): Promise<boolean>;
+    /**
+     * Force-release a lock regardless of who holds it.
+     * Admin-only operation — must be audit-logged by the caller.
+     */
+    forceReleaseLock(entityType: string, entityId: string, locale: string): Promise<boolean>;
+    /**
+     * Get the current lock for an entity+locale.
+     * Returns null if no lock or lock has expired.
+     */
+    getLock(entityType: string, entityId: string, locale: string): Promise<LockInfo | null>;
+}
+/**
+ * Factory — creates a LockService using the app's DB connection.
+ */
+declare function createLockService(): Promise<LockService>;
+
+export { LockService, type LockServiceConfig, createLockService };

package/dist/lock-service.js

@@ -0,0 +1 @@
+import"server-only";var p=5,g=class{db;constructor(r){this.db=r.db}async getTable(){let{schemaRegistry:r}=await import("@murumets-ee/db");return r.get("toolkit_content_locks")}async acquireLock(r,o,c,s){let{eq:t,and:a,lt:i}=await import("drizzle-orm"),e=await this.getTable();if(!e)return{acquired:!0};let n=new Date,d=new Date(n.getTime()+p*60*1e3);await this.db.delete(e).where(a(t(e.entityType,r),t(e.entityId,o),t(e.locale,c),i(e.expiresAt,n)));let[l]=await this.db.select().from(e).where(a(t(e.entityType,r),t(e.entityId,o),t(e.locale,c))).limit(1);return l?l.lockedBy===s.id?(await this.db.update(e).set({expiresAt:d,lockedAt:n}).where(t(e.id,l.id)),{acquired:!0}):{acquired:!1,lock:{lockedBy:l.lockedBy,lockedByName:l.lockedByName??null,lockedAt:l.lockedAt,expiresAt:l.expiresAt}}:(await this.db.insert(e).values({entityType:r,entityId:o,locale:c,lockedBy:s.id,lockedByName:s.name??null,lockedAt:n,expiresAt:d}),{acquired:!0})}async renewLock(r,o,c,s){let{eq:t,and:a,gte:i}=await import("drizzle-orm"),e=await this.getTable();if(!e)return!0;let n=new Date,d=new Date(n.getTime()+p*60*1e3);return(await this.db.update(e).set({expiresAt:d}).where(a(t(e.entityType,r),t(e.entityId,o),t(e.locale,c),t(e.lockedBy,s),i(e.expiresAt,n))).returning({id:e.id})).length>0}async releaseLock(r,o,c,s){let{eq:t,and:a}=await import("drizzle-orm"),i=await this.getTable();return i?(await this.db.delete(i).where(a(t(i.entityType,r),t(i.entityId,o),t(i.locale,c),t(i.lockedBy,s))).returning({id:i.id})).length>0:!0}async forceReleaseLock(r,o,c){let{eq:s,and:t}=await import("drizzle-orm"),a=await this.getTable();return a?(await this.db.delete(a).where(t(s(a.entityType,r),s(a.entityId,o),s(a.locale,c))).returning({id:a.id})).length>0:!0}async getLock(r,o,c){let{eq:s,and:t,gte:a}=await import("drizzle-orm"),i=await this.getTable();if(!i)return null;let e=new Date,[n]=await this.db.select().from(i).where(t(s(i.entityType,r),s(i.entityId,o),s(i.locale,c),a(i.expiresAt,e))).limit(1);return n?{lockedBy:n.lockedBy,lockedByName:n.lockedByName??null,lockedAt:n.lockedAt,expiresAt:n.expiresAt}:null}};async function y(){let{getApp:u}=await import("@murumets-ee/core"),r=u();return new g({db:r.db.readWrite})}export{g as LockService,y as createLockService};

package/dist/locks-AXFCTV7F.js

@@ -0,0 +1 @@
+import{pgTable as o,timestamp as l,unique as n,uuid as i,varchar as t}from"drizzle-orm/pg-core";var d=o("toolkit_content_locks",{id:i("id").primaryKey().defaultRandom(),entityType:t("entity_type",{length:100}).notNull(),entityId:t("entity_id",{length:255}).notNull(),locale:t("locale",{length:10}).notNull().default("_"),lockedBy:t("locked_by",{length:255}).notNull(),lockedByName:t("locked_by_name",{length:255}),lockedAt:l("locked_at",{withTimezone:!0}).notNull().defaultNow(),expiresAt:l("expires_at",{withTimezone:!0}).notNull()},e=>({uniqueEntityLock:n().on(e.entityType,e.entityId,e.locale)}));export{d as toolkitContentLocks};

package/dist/plugin.d.ts

@@ -0,0 +1,33 @@
+import { Plugin } from '@murumets-ee/core';
+import { C as ContentConfig } from './types-BYeiE1ie.js';
+import '@murumets-ee/entity';
+
+/**
+ * Content plugin — registers locale configuration and version schemas.
+ *
+ * Usage:
+ *   import { content } from '@murumets-ee/content/plugin'
+ *
+ *   export default defineConfig({
+ *     plugins: [
+ *       content({
+ *         locales: [
+ *           { code: 'en', label: 'English' },
+ *           { code: 'de', label: 'German' },
+ *         ],
+ *         defaultLocale: 'en',
+ *       }),
+ *     ],
+ *   })
+ */
+
+/**
+ * Get the content configuration. Throws if plugin not initialized.
+ */
+declare function getContentConfig(): ContentConfig;
+/**
+ * Content plugin factory.
+ */
+declare function content(config: ContentConfig): Plugin;
+
+export { content, getContentConfig };

package/dist/plugin.js

@@ -0,0 +1 @@
+var r=null;function v(){if(!r)throw new Error("@murumets-ee/content plugin not initialized. Add content() to your plugins array.");return r}function E(a){if(!a.locales||a.locales.length===0)throw new Error("content() requires at least one locale");if(!a.defaultLocale)throw new Error("content() requires a defaultLocale");if(!a.locales.some(l=>l.code===a.defaultLocale))throw new Error(`defaultLocale "${a.defaultLocale}" not found in locales: [${a.locales.map(l=>l.code).join(", ")}]`);return{name:"@murumets-ee/content",init:async l=>{r=a;let{schemaRegistry:e}=await import("@murumets-ee/db"),{generateVersionsSchema:d}=await import("./versions-4ICOJIK2.js"),{generateLocaleStatusSchema:g}=await import("./locale-status-B7B3WFXF.js"),{generateDraftsSchema:p}=await import("./drafts-2ZRAHAUK.js"),{toolkitContentLocks:y}=await import("./locks-AXFCTV7F.js"),{generateLayoutSchema:C,generateLayoutTranslationSchema:w}=await import("@murumets-ee/entity"),c=0,u=0,m=0,f=0;e.has("toolkit_content_locks")||e.register("toolkit_content_locks",y);for(let[n,o]of l.entities){if(o.behaviors?.some(t=>t.name==="versionable")){let t=`${n}_versions`;if(!e.has(t)){let s=d(o);e.register(t,s)}c++}let h=o.allFields;if(Object.values(h).some(t=>t.type==="blocks")){let t=`${n}_layout`;if(!e.has(t)){let i=C(o);i&&e.register(t,i)}let s=`${n}_layout_translations`;if(!e.has(s)){let i=w(o);i&&e.register(s,i)}u++}let b=o.behaviors?.some(t=>t.name==="publishable"),S=Object.values(h).some(t=>t.translatable);if(b&&S){let t=`${n}_locale_status`;if(!e.has(t)){let s=g(o);e.register(t,s)}m++}if(b){let t=`${n}_drafts`;if(!e.has(t)){let s=p(o);e.register(t,s)}f++}}l.logger.info({locales:a.locales.map(n=>n.code),defaultLocale:a.defaultLocale,versionableEntities:c,blockEntities:u,localeStatusEntities:m,draftEntities:f},"Content plugin initialized")}}}export{E as content,v as getContentConfig};

package/dist/query-client.d.ts

@@ -0,0 +1,67 @@
+import { Logger } from '@murumets-ee/core';
+import { Entity } from '@murumets-ee/entity';
+import { FindByIdOptions, FindManyOptions, CountOptions } from '@murumets-ee/entity/query';
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+
+/**
+ * ContentQueryClient — read-only content queries, safe for client bundles.
+ *
+ * Usage:
+ *   import { createContentQueryClient } from '@murumets-ee/content/query'
+ *   const pages = createContentQueryClient(Page)
+ *   const page = await pages.findBySlug('about', { locale: 'de' })
+ */
+
+interface ContentQueryClientConfig {
+    entity: Entity;
+    db: PostgresJsDatabase;
+    logger?: Logger;
+}
+declare class ContentQueryClient {
+    private entity;
+    private db;
+    private logger?;
+    private query;
+    constructor(config: ContentQueryClientConfig);
+    private getQuery;
+    findById(id: string, options?: FindByIdOptions): Promise<({
+        id: string;
+    } & {} & {
+        [x: string]: string | number | boolean | Record<string, unknown> | Date | Record<string, unknown>[] | {
+            [key: string]: unknown;
+            _block: string;
+            _id: string;
+        }[] | null | undefined;
+    }) | null>;
+    /**
+     * Find entity by slug — convenience for slug-based lookups.
+     */
+    findBySlug(slug: string, options?: {
+        locale?: string;
+    }): Promise<({
+        id: string;
+    } & {} & {
+        [x: string]: string | number | boolean | Record<string, unknown> | Date | Record<string, unknown>[] | {
+            [key: string]: unknown;
+            _block: string;
+            _id: string;
+        }[] | null | undefined;
+    }) | null>;
+    findMany(options?: FindManyOptions): Promise<({
+        id: string;
+    } & {} & {
+        [x: string]: string | number | boolean | Record<string, unknown> | Date | Record<string, unknown>[] | {
+            [key: string]: unknown;
+            _block: string;
+            _id: string;
+        }[] | null | undefined;
+    })[]>;
+    count(options?: CountOptions): Promise<number>;
+}
+/**
+ * Factory — creates a ContentQueryClient for an entity.
+ * Must be called after createApp().
+ */
+declare function createContentQueryClient(entity: Entity): Promise<ContentQueryClient>;
+
+export { ContentQueryClient, type ContentQueryClientConfig, createContentQueryClient };

package/dist/query-client.js

@@ -0,0 +1 @@
+var i=class{entity;db;logger;query=null;constructor(t){this.entity=t.entity,this.db=t.db,this.logger=t.logger}async getQuery(){if(!this.query){let{QueryClient:t}=await import("@murumets-ee/entity/query");this.query=new t({entity:this.entity,db:this.db,logger:this.logger})}return this.query}async findById(t,e){return(await this.getQuery()).findById(t,e)}async findBySlug(t,e){let{schemaRegistry:s}=await import("@murumets-ee/db"),{eq:o}=await import("drizzle-orm"),n=s.get(this.entity.name);return!n||!n.slug?null:(await(await this.getQuery()).findMany({where:o(n.slug,t),limit:1,locale:e?.locale}))[0]??null}async findMany(t){return(await this.getQuery()).findMany(t)}async count(t){return(await this.getQuery()).count(t)}};async function u(r){let{getApp:t}=await import("@murumets-ee/core"),e=t();return new i({entity:r,db:e.db.readOnly,logger:e.logger.child({content:r.name})})}export{i as ContentQueryClient,u as createContentQueryClient};

package/dist/types-BYeiE1ie.d.ts

@@ -0,0 +1,99 @@
+import { FieldConfig, InferEntityDTO } from '@murumets-ee/entity';
+
+/**
+ * Content package types
+ */
+
+/**
+ * A block definition — describes a reusable content block's data shape.
+ *
+ * @typeParam F - The literal field map, inferred from the call site.
+ */
+interface BlockDefinition<F extends Record<string, FieldConfig> = Record<string, FieldConfig>> {
+    slug: string;
+    label: string;
+    fields: F;
+}
+/**
+ * Infer the data shape of a single block definition.
+ * Produces `{ _block: 'hero'; _id: string; heading: string; ... }`
+ */
+type InferBlockData<B extends BlockDefinition> = B extends BlockDefinition<infer F> ? {
+    _block: B['slug'];
+    _id: string;
+} & Omit<InferEntityDTO<F>, 'id'> : never;
+/**
+ * Infer a discriminated union from a tuple of block definitions.
+ *
+ * @example
+ * type Layout = InferBlocksUnion<typeof [HeroBlock, RichTextBlock]>
+ * // = { _block: 'hero'; ... } | { _block: 'richtext'; ... }
+ */
+type InferBlocksUnion<T extends readonly BlockDefinition[]> = {
+    [K in keyof T]: T[K] extends BlockDefinition ? InferBlockData<T[K]> : never;
+}[number];
+interface LocaleConfig {
+    code: string;
+    label: string;
+}
+interface ContentConfig {
+    locales: LocaleConfig[];
+    defaultLocale: string;
+}
+interface VersionableOptions {
+    /** Maximum versions kept per document. Default: 50 */
+    maxPerDoc?: number;
+    /** Enable autosave (single mutable autosave version). Default: false */
+    autosave?: boolean;
+}
+interface VersionEntry {
+    id: string;
+    entityId: string;
+    version: number;
+    locale: string;
+    data: Record<string, unknown>;
+    delta: Record<string, unknown> | null;
+    status: string | null;
+    createdBy: string | null;
+    createdByName: string | null;
+    createdAt: Date | string;
+    isAutosave: boolean;
+}
+interface TranslationFieldStatus {
+    complete: boolean;
+    total: number;
+    translated: number;
+    missing: string[];
+}
+interface TranslationStatus {
+    [locale: string]: TranslationFieldStatus;
+}
+interface TranslationReport {
+    total: number;
+    complete: number;
+    partial: number;
+    missing: number;
+}
+interface LocalePublishStatus {
+    locale: string;
+    status: 'draft' | 'published';
+    publishedAt: Date | string | null;
+}
+interface DraftEntry {
+    id: string;
+    entityId: string;
+    locale: string;
+    data: Record<string, unknown>;
+    createdBy: string;
+    createdByName: string | null;
+    createdAt: Date | string;
+    updatedAt: Date | string;
+}
+interface LockInfo {
+    lockedBy: string;
+    lockedByName: string | null;
+    lockedAt: Date | string;
+    expiresAt: Date | string;
+}
+
+export type { BlockDefinition as B, ContentConfig as C, DraftEntry as D, InferBlockData as I, LocalePublishStatus as L, TranslationStatus as T, VersionEntry as V, TranslationReport as a, VersionableOptions as b, InferBlocksUnion as c, LocaleConfig as d, LockInfo as e, TranslationFieldStatus as f };

package/dist/types-Cr0ifLn_.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Diff result types for version comparison.
+ */
+/** A segment within a word-level text diff. */
+interface DiffSegment {
+    type: 'equal' | 'add' | 'remove';
+    value: string;
+}
+/** Diff result for a single scalar field. */
+interface FieldDiff {
+    field: string;
+    type: 'text' | 'number' | 'boolean' | 'date' | 'select' | 'media' | 'richtext' | 'json' | 'blocks' | 'unknown';
+    from: unknown;
+    to: unknown;
+    /** Word-level diff segments (present for text/richtext/slug fields). */
+    segments?: DiffSegment[];
+    /** Block-level structural diff (present for blocks fields). */
+    blockDiffs?: BlockDiffEntry[];
+}
+/** Status of a single block within a structural diff. */
+type BlockDiffStatus = 'added' | 'removed' | 'moved' | 'changed' | 'unchanged';
+/** Diff result for a single block within a blocks field. */
+interface BlockDiffEntry {
+    blockId: string;
+    blockType: string;
+    status: BlockDiffStatus;
+    fromIndex?: number;
+    toIndex?: number;
+    /** Per-prop diffs for changed blocks. */
+    propDiffs?: PropDiff[];
+}
+/** Diff for a single prop within a changed block. */
+interface PropDiff {
+    field: string;
+    from: unknown;
+    to: unknown;
+    /** Word-level segments for string props. */
+    segments?: DiffSegment[];
+}
+
+export type { BlockDiffEntry as B, DiffSegment as D, FieldDiff as F, PropDiff as P, BlockDiffStatus as a };

package/dist/versions-4ICOJIK2.js

@@ -0,0 +1 @@
+import{boolean as i,integer as r,jsonb as a,pgTable as u,timestamp as d,unique as s,uuid as n,varchar as e}from"drizzle-orm/pg-core";function c(o){let l=`${o.name}_versions`;return u(l,{id:n("id").primaryKey().defaultRandom(),entityId:n("entity_id").notNull(),version:r("version").notNull(),locale:e("locale",{length:10}).notNull().default("_"),data:a("data").notNull(),delta:a("delta"),status:e("status",{length:20}),createdBy:e("created_by",{length:255}),createdByName:e("created_by_name",{length:255}),createdAt:d("created_at",{withTimezone:!0}).notNull().defaultNow(),isAutosave:i("is_autosave").notNull().default(!1)},t=>({uniqueEntityVersionLocale:s().on(t.entityId,t.version,t.locale)}))}export{c as generateVersionsSchema};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@murumets-ee/content",
+  "version": "0.1.0",
+  "license": "Elastic-2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./query": {
+      "types": "./dist/query-client.d.ts",
+      "import": "./dist/query-client.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js"
+    },
+    "./blocks": {
+      "types": "./dist/blocks/index.d.ts",
+      "import": "./dist/blocks/index.js"
+    },
+    "./lock": {
+      "types": "./dist/lock-service.d.ts",
+      "import": "./dist/lock-service.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "drizzle-orm": "^0.45.1",
+    "server-only": "^0.0.1",
+    "zod": "^3.24.1",
+    "@murumets-ee/core": "0.1.0",
+    "@murumets-ee/logging": "0.1.0",
+    "@murumets-ee/entity": "0.1.0",
+    "@murumets-ee/db": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest"
+  }
+}