@beechcms/core 0.4.0-preview.1

package/dist/define-seed.d.ts

@@ -0,0 +1,3 @@
+import type { Seed } from './types.js';
+export declare function defineSeed(seed: Seed): Seed;
+//# sourceMappingURL=define-seed.d.ts.map

package/dist/define-seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-seed.d.ts","sourceRoot":"","sources":["../src/define-seed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEtC,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAE3C"}

package/dist/define-seed.js

@@ -0,0 +1,3 @@
+export function defineSeed(seed) {
+    return seed;
+}

package/dist/engine.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Botanical Engine: Schema Compiler + Query Builder.
+ *
+ * In v0.4.0 ogni Seed ha una tabella SQL dedicata (`content_{slug}`) con colonne
+ * reali tipizzate. Questo modulo genera il DDL e costruisce query parametrizzate.
+ * Non conosce HTTP, auth o UI — è una libreria Node.js pura (C6).
+ */
+import type { Seed, Branch, SelectOptions, ParameterizedQuery } from './types.js';
+/**
+ * Genera `CREATE TABLE IF NOT EXISTS content_{slug}` con colonne di sistema
+ * + una colonna per ogni Branch. Funzione pura: stesso Seed → stesso SQL.
+ */
+export declare function generateCreateTable(seed: Seed): string;
+/**
+ * Genera la tabella bozze `content_{slug}_drafts` per i Seed con `allowDrafts: true`.
+ * Tutte le colonne branch sono nullable (le bozze sono parziali).
+ * Ritorna null se il Seed non ha `allowDrafts: true`.
+ */
+export declare function generateDraftTable(seed: Seed): string | null;
+/**
+ * Genera `ALTER TABLE content_{slug} ADD COLUMN {alias} {type}`.
+ * Nuove colonne sono sempre nullable (limite SQLite su ALTER TABLE).
+ */
+export declare function generateAddColumn(seed: Seed, branch: Branch): string;
+/**
+ * Genera indici B-tree per status, created_at e ogni Branch filtrabile
+ * con tipo indicizzabile (text, number, date, boolean).
+ */
+export declare function generateIndexes(seed: Seed): string[];
+/**
+ * Genera la virtual table FTS5 per i Branch text/richtext indicizzabili.
+ * Ritorna null se il Seed non ha branch con search abilitato.
+ */
+export declare function generateFtsTable(seed: Seed): string | null;
+/**
+ * Genera i 3 trigger SQLite (insert/update/delete) che mantengono la FTS
+ * sincronizzata automaticamente — elimina la necessità di syncFts manuale.
+ * Ritorna array vuoto se il Seed non ha branch indicizzabili.
+ */
+export declare function generateFtsTriggers(seed: Seed): string[];
+/**
+ * Costruisce una SELECT parametrizzata su `content_{slug}`.
+ * Non usa mai json_extract — ogni colonna è una colonna reale.
+ * Colonne sconosciute nei filtri/orderBy vengono ignorate (fail-closed).
+ */
+export declare function buildSelectQuery(seed: Seed, options?: SelectOptions): ParameterizedQuery;
+export interface SchemaColumn {
+    name: string;
+    sqlType: 'TEXT' | 'REAL' | 'INTEGER';
+    notNull: boolean;
+    isPk: boolean;
+}
+/**
+ * Ritorna la lista di colonne attese per la tabella di un Seed.
+ * Usato da `beech seed:load --diff` per confrontare schema attuale vs atteso.
+ */
+export declare function getExpectedColumns(seed: Seed): SchemaColumn[];
+/**
+ * Serializza un valore per la scrittura nel DB.
+ * boolean → 0/1 | date → Unix timestamp | json/asset-list → JSON string
+ */
+export declare function serializeForDb(branch: Branch, value: unknown): string | number | null;
+/**
+ * Deserializza un valore letto dal DB per la risposta API.
+ * 0/1 → boolean | Unix timestamp → ISO 8601 | JSON string → object
+ */
+export declare function deserializeFromDb(branch: Branch, value: unknown): unknown;
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EACV,IAAI,EACJ,MAAM,EAKN,aAAa,EACb,kBAAkB,EACnB,MAAM,YAAY,CAAA;AA+EnB;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAsBtD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAuB5D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAGpE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,CAkBpD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAc1D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,CAgCxD;AAID;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,GAAE,aAAkB,GAAG,kBAAkB,CAqE5F;AA0CD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;IACpC,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,OAAO,CAAA;CACd;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,YAAY,EAAE,CAc7D;AAID;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAkCrF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CA4BzE"}

package/dist/engine.js

@@ -0,0 +1,401 @@
+const BRANCH_TYPE_SQL = {
+    text: { sqlType: 'TEXT' },
+    number: { sqlType: 'REAL' },
+    boolean: { sqlType: 'INTEGER' },
+    date: { sqlType: 'INTEGER' }, // Unix timestamp (seconds)
+    json: { sqlType: 'TEXT' }, // JSON serializzato
+    richtext: { sqlType: 'TEXT' },
+    file: { sqlType: 'TEXT' }, // URL singolo o JSON array di URL
+};
+const SYSTEM_COLUMNS = new Set(['id', 'slug', 'status', 'created_at', 'updated_at']);
+// ---- Private helpers ----
+function tableName(seed) {
+    return `content_${seed.slug}`;
+}
+function ftsTableName(seed) {
+    return `fts_${seed.slug}`;
+}
+function isValidColumn(seed, col) {
+    if (SYSTEM_COLUMNS.has(col))
+        return true;
+    return seed.branches.some(b => b.alias === col);
+}
+function indexableSearchBranches(seed) {
+    return seed.branches.filter(b => (b.type === 'text' || b.type === 'richtext') && b.policies?.search !== false);
+}
+function isAssetListBranch(branch) {
+    return branch.type === 'file' && (branch.multiple === true || branch.format === 'asset-list');
+}
+function normalizeHttpUrl(value) {
+    if (typeof value !== 'string')
+        return null;
+    const cleaned = value.trim();
+    if (!cleaned)
+        return null;
+    try {
+        const parsed = new URL(cleaned);
+        return parsed.protocol.startsWith('http') ? cleaned : null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseJsonSafe(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function normalizeAssetListValue(rawValue) {
+    const input = typeof rawValue === 'string' ? parseJsonSafe(rawValue) : rawValue;
+    const values = Array.isArray(input) ? input : [input];
+    const normalized = [];
+    for (const item of values) {
+        if (item == null)
+            continue;
+        const direct = normalizeHttpUrl(item);
+        if (direct) {
+            normalized.push(direct);
+            continue;
+        }
+        if (typeof item === 'object' && !Array.isArray(item)) {
+            const fromObj = normalizeHttpUrl(item.url);
+            if (fromObj)
+                normalized.push(fromObj);
+        }
+    }
+    return [...new Set(normalized)];
+}
+// ---- DDL Generators ----
+/**
+ * Genera `CREATE TABLE IF NOT EXISTS content_{slug}` con colonne di sistema
+ * + una colonna per ogni Branch. Funzione pura: stesso Seed → stesso SQL.
+ */
+export function generateCreateTable(seed) {
+    const table = tableName(seed);
+    const lines = [
+        `CREATE TABLE IF NOT EXISTS ${table} (`,
+        `  id         TEXT    NOT NULL PRIMARY KEY,`,
+        `  slug       TEXT    NOT NULL UNIQUE,`,
+        `  status     TEXT    NOT NULL DEFAULT 'draft' CHECK (status IN ('draft', 'review', 'published', 'archived')),`,
+    ];
+    for (const branch of seed.branches) {
+        const { sqlType } = BRANCH_TYPE_SQL[branch.type];
+        let col = `  ${branch.alias}  ${sqlType}`;
+        if (branch.requiredOnCreate)
+            col += ' NOT NULL';
+        if (branch.type === 'boolean')
+            col += ` CHECK (${branch.alias} IN (0, 1))`;
+        lines.push(col + ',');
+    }
+    lines.push(`  created_at INTEGER NOT NULL DEFAULT (unixepoch()),`);
+    lines.push(`  updated_at INTEGER NOT NULL DEFAULT (unixepoch())`);
+    lines.push(`);`);
+    return lines.join('\n');
+}
+/**
+ * Genera la tabella bozze `content_{slug}_drafts` per i Seed con `allowDrafts: true`.
+ * Tutte le colonne branch sono nullable (le bozze sono parziali).
+ * Ritorna null se il Seed non ha `allowDrafts: true`.
+ */
+export function generateDraftTable(seed) {
+    if (!seed.allowDrafts)
+        return null;
+    const table = `content_${seed.slug}_drafts`;
+    const mainTable = `content_${seed.slug}`;
+    const lines = [
+        `CREATE TABLE IF NOT EXISTS ${table} (`,
+        `  entry_id  TEXT NOT NULL PRIMARY KEY`,
+        `            REFERENCES ${mainTable}(id) ON DELETE CASCADE,`,
+    ];
+    for (const branch of seed.branches) {
+        const { sqlType } = BRANCH_TYPE_SQL[branch.type];
+        let col = `  ${branch.alias}  ${sqlType}`;
+        // boolean CHECK: in SQLite, NULL IN (0,1) → NULL, che passa il CHECK (solo FALSE lo fallisce)
+        if (branch.type === 'boolean')
+            col += ` CHECK (${branch.alias} IN (0, 1))`;
+        lines.push(col + ',');
+    }
+    lines.push(`  updated_at  INTEGER NOT NULL DEFAULT (unixepoch())`);
+    lines.push(`);`);
+    return lines.join('\n');
+}
+/**
+ * Genera `ALTER TABLE content_{slug} ADD COLUMN {alias} {type}`.
+ * Nuove colonne sono sempre nullable (limite SQLite su ALTER TABLE).
+ */
+export function generateAddColumn(seed, branch) {
+    const { sqlType } = BRANCH_TYPE_SQL[branch.type];
+    return `ALTER TABLE ${tableName(seed)} ADD COLUMN ${branch.alias} ${sqlType};`;
+}
+/**
+ * Genera indici B-tree per status, created_at e ogni Branch filtrabile
+ * con tipo indicizzabile (text, number, date, boolean).
+ */
+export function generateIndexes(seed) {
+    const table = tableName(seed);
+    const slug = seed.slug;
+    const indexes = [
+        `CREATE INDEX IF NOT EXISTS idx_${slug}_status ON ${table}(status);`,
+        `CREATE INDEX IF NOT EXISTS idx_${slug}_created_at ON ${table}(created_at);`,
+    ];
+    for (const branch of seed.branches) {
+        if (branch.policies?.filter === false)
+            continue;
+        if (['text', 'number', 'date', 'boolean'].includes(branch.type)) {
+            indexes.push(`CREATE INDEX IF NOT EXISTS idx_${slug}_${branch.alias} ON ${table}(${branch.alias});`);
+        }
+    }
+    return indexes;
+}
+/**
+ * Genera la virtual table FTS5 per i Branch text/richtext indicizzabili.
+ * Ritorna null se il Seed non ha branch con search abilitato.
+ */
+export function generateFtsTable(seed) {
+    const rtBranches = indexableSearchBranches(seed);
+    if (rtBranches.length === 0)
+        return null;
+    const ftsTable = ftsTableName(seed);
+    const cols = rtBranches.map(b => `  ${b.alias}`).join(',\n');
+    return [
+        `CREATE VIRTUAL TABLE IF NOT EXISTS ${ftsTable} USING fts5(`,
+        `  entry_id UNINDEXED,`,
+        `${cols},`,
+        `  tokenize = 'unicode61'`,
+        `);`,
+    ].join('\n');
+}
+/**
+ * Genera i 3 trigger SQLite (insert/update/delete) che mantengono la FTS
+ * sincronizzata automaticamente — elimina la necessità di syncFts manuale.
+ * Ritorna array vuoto se il Seed non ha branch indicizzabili.
+ */
+export function generateFtsTriggers(seed) {
+    const rtBranches = indexableSearchBranches(seed);
+    if (rtBranches.length === 0)
+        return [];
+    const table = tableName(seed);
+    const ftsTable = ftsTableName(seed);
+    const slug = seed.slug;
+    const cols = rtBranches.map(b => b.alias);
+    const ftsColList = ['entry_id', ...cols].join(', ');
+    const newValList = ['new.id', ...cols.map(c => `new.${c}`)].join(', ');
+    return [
+        [
+            `CREATE TRIGGER IF NOT EXISTS fts_${slug}_insert`,
+            `AFTER INSERT ON ${table} BEGIN`,
+            `  INSERT INTO ${ftsTable}(${ftsColList}) VALUES (${newValList});`,
+            `END;`,
+        ].join('\n'),
+        [
+            `CREATE TRIGGER IF NOT EXISTS fts_${slug}_update`,
+            `AFTER UPDATE OF ${cols.join(', ')} ON ${table} BEGIN`,
+            `  DELETE FROM ${ftsTable} WHERE entry_id = old.id;`,
+            `  INSERT INTO ${ftsTable}(${ftsColList}) VALUES (${newValList});`,
+            `END;`,
+        ].join('\n'),
+        [
+            `CREATE TRIGGER IF NOT EXISTS fts_${slug}_delete`,
+            `AFTER DELETE ON ${table} BEGIN`,
+            `  DELETE FROM ${ftsTable} WHERE entry_id = old.id;`,
+            `END;`,
+        ].join('\n'),
+    ];
+}
+// ---- Query Builder ----
+/**
+ * Costruisce una SELECT parametrizzata su `content_{slug}`.
+ * Non usa mai json_extract — ogni colonna è una colonna reale.
+ * Colonne sconosciute nei filtri/orderBy vengono ignorate (fail-closed).
+ */
+export function buildSelectQuery(seed, options = {}) {
+    const table = tableName(seed);
+    const { filters = [], orderBy, pagination, status, search, fields } = options;
+    const bindings = [];
+    const whereClauses = [];
+    let joinClause = '';
+    // FTS JOIN — solo se il seed ha branch indicizzabili
+    const rtBranches = indexableSearchBranches(seed);
+    if (search && rtBranches.length > 0) {
+        const ftsTable = ftsTableName(seed);
+        joinClause = `INNER JOIN ${ftsTable} ON ${ftsTable}.entry_id = ${table}.id`;
+        whereClauses.push(`${ftsTable} MATCH ?`);
+        // FTS5: prefix match con quote per caratteri speciali
+        bindings.push(`"${search.replace(/"/g, '""')}"*`);
+    }
+    // Filtro status
+    if (status !== undefined && status !== null) {
+        whereClauses.push(`${table}.status = ?`);
+        bindings.push(status);
+    }
+    // Filtri utente
+    for (const group of filters) {
+        if (!isValidColumn(seed, group.column))
+            continue;
+        const col = SYSTEM_COLUMNS.has(group.column)
+            ? `${table}.${group.column}`
+            : group.column;
+        for (const cond of group.conditions) {
+            const clause = buildFilterCondition(col, group.type, cond, bindings);
+            if (clause)
+                whereClauses.push(clause);
+        }
+    }
+    // Proiezione colonne
+    let selectCols = `${table}.*`;
+    if (fields && fields.length > 0) {
+        const valid = fields.filter(f => isValidColumn(seed, f));
+        if (valid.length > 0) {
+            selectCols = valid
+                .map(f => (SYSTEM_COLUMNS.has(f) ? `${table}.${f}` : f))
+                .join(', ');
+        }
+    }
+    let sql = `SELECT ${selectCols} FROM ${table}`;
+    if (joinClause)
+        sql += ` ${joinClause}`;
+    if (whereClauses.length > 0)
+        sql += ` WHERE ${whereClauses.join(' AND ')}`;
+    // ORDER BY
+    if (orderBy && isValidColumn(seed, orderBy.column)) {
+        const dir = orderBy.dir === 'DESC' ? 'DESC' : 'ASC';
+        const col = SYSTEM_COLUMNS.has(orderBy.column)
+            ? `${table}.${orderBy.column}`
+            : orderBy.column;
+        sql += ` ORDER BY ${col} ${dir}`;
+    }
+    else {
+        sql += ` ORDER BY ${table}.created_at DESC`;
+    }
+    // Paginazione
+    if (pagination) {
+        sql += ` LIMIT ? OFFSET ?`;
+        bindings.push(pagination.limit, pagination.offset);
+    }
+    return { sql, bindings };
+}
+function buildFilterCondition(col, type, cond, bindings) {
+    const { op, value } = cond;
+    if (op === 'is_empty') {
+        return type === 'text' ? `(${col} IS NULL OR ${col} = '')` : `${col} IS NULL`;
+    }
+    if (op === 'is_not_empty') {
+        return type === 'text' ? `(${col} IS NOT NULL AND ${col} != '')` : `${col} IS NOT NULL`;
+    }
+    if (value === null || value === undefined)
+        return null;
+    if (op === 'eq') {
+        bindings.push(type === 'boolean' ? (value ? 1 : 0) : value);
+        return `${col} = ?`;
+    }
+    if (op === 'contains') {
+        if (type === 'tags') {
+            bindings.push(String(value));
+            return `EXISTS (SELECT 1 FROM json_each(${col}) WHERE value = ?)`;
+        }
+        bindings.push(`%${String(value)}%`);
+        return `${col} LIKE ?`;
+    }
+    const mathOps = { gt: '>', gte: '>=', lt: '<', lte: '<=' };
+    if (mathOps[op]) {
+        bindings.push(value);
+        return `${col} ${mathOps[op]} ?`;
+    }
+    return null;
+}
+/**
+ * Ritorna la lista di colonne attese per la tabella di un Seed.
+ * Usato da `beech seed:load --diff` per confrontare schema attuale vs atteso.
+ */
+export function getExpectedColumns(seed) {
+    return [
+        { name: 'id', sqlType: 'TEXT', notNull: true, isPk: true },
+        { name: 'slug', sqlType: 'TEXT', notNull: true, isPk: false },
+        { name: 'status', sqlType: 'TEXT', notNull: true, isPk: false },
+        ...seed.branches.map(b => ({
+            name: b.alias,
+            sqlType: BRANCH_TYPE_SQL[b.type].sqlType,
+            notNull: b.requiredOnCreate ?? false,
+            isPk: false,
+        })),
+        { name: 'created_at', sqlType: 'INTEGER', notNull: true, isPk: false },
+        { name: 'updated_at', sqlType: 'INTEGER', notNull: true, isPk: false },
+    ];
+}
+// ---- Serialization / Deserialization ----
+/**
+ * Serializza un valore per la scrittura nel DB.
+ * boolean → 0/1 | date → Unix timestamp | json/asset-list → JSON string
+ */
+export function serializeForDb(branch, value) {
+    if (value === null || value === undefined)
+        return null;
+    switch (branch.type) {
+        case 'boolean':
+            return value ? 1 : 0;
+        case 'json':
+        case 'richtext':
+            return typeof value === 'string' ? value : JSON.stringify(value);
+        case 'date': {
+            if (typeof value === 'number')
+                return value;
+            if (typeof value === 'string') {
+                const d = new Date(value);
+                if (isNaN(d.getTime()))
+                    return null;
+                if (branch.format === 'date') {
+                    const midnight = Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+                    return Math.floor(midnight / 1000);
+                }
+                return Math.floor(d.getTime() / 1000);
+            }
+            return null;
+        }
+        case 'file':
+            if (isAssetListBranch(branch)) {
+                return Array.isArray(value) ? JSON.stringify(value) : typeof value === 'string' ? value : null;
+            }
+            return typeof value === 'string' ? value : null;
+        default:
+            return typeof value === 'string' ? value : typeof value === 'number' ? value : null;
+    }
+}
+/**
+ * Deserializza un valore letto dal DB per la risposta API.
+ * 0/1 → boolean | Unix timestamp → ISO 8601 | JSON string → object
+ */
+export function deserializeFromDb(branch, value) {
+    if (value === null || value === undefined)
+        return null;
+    switch (branch.type) {
+        case 'boolean':
+            return value === 1 || value === true;
+        case 'json':
+        case 'richtext': {
+            if (typeof value === 'string') {
+                try {
+                    return JSON.parse(value);
+                }
+                catch {
+                    return value;
+                }
+            }
+            return value;
+        }
+        case 'date': {
+            if (typeof value !== 'number')
+                return null;
+            const d = new Date(value * 1000);
+            return branch.format === 'date' ? d.toISOString().slice(0, 10) : d.toISOString();
+        }
+        case 'file':
+            if (isAssetListBranch(branch))
+                return normalizeAssetListValue(value);
+            return typeof value === 'string' ? value : null;
+        default:
+            return value;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @beechcms/core - Botanical Engine
+ *
+ * Pacchetto condiviso del monorepo Beech CMS.
+ * In v0.4.0 il Botanical Engine è un compilatore di schema SQL: legge i Seed
+ * TypeScript e genera DDL deterministico + query parametrizzate.
+ *
+ * @module @beechcms/core
+ */
+export * from './types.js';
+export * from './define-seed.js';
+export * from './seeds.js';
+export * from './engine.js';
+export * from './validation.js';
+export * from './richtext.js';
+export * from './richtext-render.js';
+export * from './slug-utils.js';
+export * from './policies.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,cAAc,YAAY,CAAA;AAC1B,cAAc,kBAAkB,CAAA;AAChC,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,sBAAsB,CAAA;AACpC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA"}

package/dist/index.js

@@ -0,0 +1,18 @@
+/**
+ * @beechcms/core - Botanical Engine
+ *
+ * Pacchetto condiviso del monorepo Beech CMS.
+ * In v0.4.0 il Botanical Engine è un compilatore di schema SQL: legge i Seed
+ * TypeScript e genera DDL deterministico + query parametrizzate.
+ *
+ * @module @beechcms/core
+ */
+export * from './types.js';
+export * from './define-seed.js';
+export * from './seeds.js';
+export * from './engine.js';
+export * from './validation.js';
+export * from './richtext.js';
+export * from './richtext-render.js';
+export * from './slug-utils.js';
+export * from './policies.js';

package/dist/policies.d.ts

@@ -0,0 +1,10 @@
+import type { Branch } from './types.js';
+export declare function sha256hex(value: string): Promise<string>;
+export declare function verifyHashField(stored: string, candidate: string): Promise<boolean>;
+/**
+ * Risolve le policy di un branch applicando i valori di default.
+ * Tutta la logica di accesso ai campi deve passare per questa funzione,
+ * mai con inline `branch.policies?.x ?? default`.
+ */
+export declare function resolvePolicies(branch: Branch): Required<NonNullable<Branch['policies']>>;
+//# sourceMappingURL=policies.d.ts.map

package/dist/policies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policies.d.ts","sourceRoot":"","sources":["../src/policies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExC,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAK9D;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAEzF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAazF"}

package/dist/policies.js

@@ -0,0 +1,28 @@
+export async function sha256hex(value) {
+    const buf = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(value));
+    return Array.from(new Uint8Array(buf))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+export async function verifyHashField(stored, candidate) {
+    return stored === (await sha256hex(candidate));
+}
+/**
+ * Risolve le policy di un branch applicando i valori di default.
+ * Tutta la logica di accesso ai campi deve passare per questa funzione,
+ * mai con inline `branch.policies?.x ?? default`.
+ */
+export function resolvePolicies(branch) {
+    const privacy = branch.policies?.privacy ?? 'plain';
+    // Non-plain privacy implies hidden by default: the CMS hashes/encrypts on write,
+    // so returning the stored value would leak the digest to readers.
+    const defaultVisibility = privacy !== 'plain' ? 'hidden' : 'full';
+    return {
+        privacy,
+        visibility: branch.policies?.visibility ?? defaultVisibility,
+        search: branch.policies?.search ?? true,
+        filter: branch.policies?.filter ?? true,
+        sort: branch.policies?.sort ?? true,
+        public: branch.policies?.public ?? true,
+    };
+}

package/dist/richtext-render.d.ts

@@ -0,0 +1,11 @@
+import type { JSONContent } from '@tiptap/core';
+/**
+ * Accetta JSON TipTap (`{ type: 'doc', ... }`), envelope v1, o stringa HTML legacy.
+ */
+export declare function normalizeRichtextForRender(value: unknown): JSONContent | string | null;
+/**
+ * Render deterministico JSON → HTML (per display, anteprime, API pubblica).
+ * Per stringhe HTML legacy restituisce la stringa sanificata come pass-through (nessun parse TipTap).
+ */
+export declare function renderRichText(value: unknown): string;
+//# sourceMappingURL=richtext-render.d.ts.map

package/dist/richtext-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"richtext-render.d.ts","sourceRoot":"","sources":["../src/richtext-render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAuD/C;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,GAAG,MAAM,GAAG,IAAI,CAatF;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAQrD"}

package/dist/richtext-render.js

@@ -0,0 +1,85 @@
+import { generateHTML } from '@tiptap/html';
+import Highlight from '@tiptap/extension-highlight';
+import Image from '@tiptap/extension-image';
+import Link from '@tiptap/extension-link';
+import Subscript from '@tiptap/extension-subscript';
+import Superscript from '@tiptap/extension-superscript';
+import { Table, TableCell, TableHeader, TableRow } from '@tiptap/extension-table';
+import TextAlign from '@tiptap/extension-text-align';
+import { Mathematics } from '@tiptap/extension-mathematics';
+import StarterKit from '@tiptap/starter-kit';
+import { isRichtextEnvelopeV1 } from './richtext.js';
+/**
+ * Allinea l'output HTML allo schema TipTap usato dall'editor dashboard.
+ * Mantieni sincronizzato con `apps/dashboard/src/features/richtext-editor/extensions/build-editor-extensions.ts`.
+ */
+function createRichTextHtmlExtensions() {
+    return [
+        StarterKit.configure({
+            link: false,
+            codeBlock: {
+                HTMLAttributes: {
+                    class: 'richtext-code-block',
+                },
+            },
+        }),
+        Link.configure({
+            openOnClick: false,
+            autolink: true,
+            defaultProtocol: 'https',
+        }),
+        Mathematics.configure({
+            katexOptions: {
+                throwOnError: false,
+            },
+        }),
+        Highlight,
+        Superscript,
+        Subscript,
+        Image.configure({
+            allowBase64: false,
+        }),
+        TextAlign.configure({
+            types: ['heading', 'paragraph'],
+        }),
+        Table.configure({
+            resizable: false,
+        }),
+        TableRow,
+        TableHeader,
+        TableCell,
+    ];
+}
+/**
+ * Accetta JSON TipTap (`{ type: 'doc', ... }`), envelope v1, o stringa HTML legacy.
+ */
+export function normalizeRichtextForRender(value) {
+    if (value == null || value === '')
+        return null;
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        const o = value;
+        if (isRichtextEnvelopeV1(value)) {
+            return o.doc;
+        }
+        if (o.type === 'doc') {
+            return value;
+        }
+    }
+    return null;
+}
+/**
+ * Render deterministico JSON → HTML (per display, anteprime, API pubblica).
+ * Per stringhe HTML legacy restituisce la stringa sanificata come pass-through (nessun parse TipTap).
+ */
+export function renderRichText(value) {
+    const normalized = normalizeRichtextForRender(value);
+    if (normalized == null)
+        return '';
+    if (typeof normalized === 'string') {
+        return normalized;
+    }
+    const extensions = createRichTextHtmlExtensions();
+    return generateHTML(normalized, extensions);
+}