includio-cms 0.7.2 → 0.13.0

package/dist/core/server/media/styles/operations/batchGenerateStyles.js

@@ -0,0 +1,144 @@
+import { getCMS } from '../../../../cms.js';
+import { isProcessableImage, defaultStyles, expandStyleFormats, getOriginalFormat } from '../../../fields/utils/imageStyles.js';
+import { getImageStyle } from './getImageStyle.js';
+const IMAGE_MIME_TYPES = [
+    'image/jpeg',
+    'image/png',
+    'image/webp',
+    'image/avif',
+    'image/gif',
+    'image/tiff'
+];
+async function generateStylesForFile(file) {
+    const cms = getCMS();
+    const origFormat = getOriginalFormat(file);
+    const expanded = expandStyleFormats(defaultStyles, origFormat);
+    let created = 0;
+    let skipped = 0;
+    for (const style of expanded) {
+        const existing = await cms.databaseAdapter.getImageStyle(file.id, style);
+        if (existing) {
+            skipped++;
+        }
+        else {
+            await getImageStyle(file.id, style);
+            created++;
+        }
+        if (style.srcset && file.width) {
+            const widths = style.srcset.filter((w) => w <= file.width);
+            for (const w of widths) {
+                const widthStyle = {
+                    ...style,
+                    name: `${style.name}_${w}w`,
+                    width: w,
+                    srcset: undefined,
+                    sizes: undefined
+                };
+                const existingW = await cms.databaseAdapter.getImageStyle(file.id, widthStyle);
+                if (existingW) {
+                    skipped++;
+                }
+                else {
+                    await getImageStyle(file.id, widthStyle);
+                    created++;
+                }
+            }
+        }
+    }
+    return { created, skipped };
+}
+export async function* batchGenerateAllStyles(signal) {
+    const allFiles = await getCMS().databaseAdapter.getMediaFiles({
+        data: { mimeTypes: IMAGE_MIME_TYPES }
+    });
+    const files = allFiles.filter(isProcessableImage);
+    const total = files.length;
+    let totalCreated = 0;
+    let totalSkipped = 0;
+    for (let i = 0; i < files.length; i++) {
+        if (signal?.aborted)
+            return;
+        const file = files[i];
+        yield {
+            type: 'progress',
+            total,
+            processed: i,
+            created: totalCreated,
+            skipped: totalSkipped,
+            currentFile: file.name
+        };
+        try {
+            const { created, skipped } = await generateStylesForFile(file);
+            totalCreated += created;
+            totalSkipped += skipped;
+        }
+        catch (e) {
+            yield {
+                type: 'error',
+                total,
+                processed: i + 1,
+                created: totalCreated,
+                skipped: totalSkipped,
+                currentFile: file.name,
+                error: e instanceof Error ? e.message : String(e)
+            };
+            continue;
+        }
+    }
+    yield { type: 'done', total, processed: total, created: totalCreated, skipped: totalSkipped };
+}
+function getExpectedStyleNames(file) {
+    const origFormat = getOriginalFormat(file);
+    const expanded = expandStyleFormats(defaultStyles, origFormat);
+    const names = [];
+    for (const style of expanded) {
+        names.push(style.name);
+        if (style.srcset && file.width) {
+            for (const w of style.srcset.filter((sw) => sw <= file.width)) {
+                names.push(`${style.name}_${w}w`);
+            }
+        }
+    }
+    return names;
+}
+export async function getStylesStatus() {
+    const cms = getCMS();
+    const [allFiles, allStyles] = await Promise.all([
+        cms.databaseAdapter.getMediaFiles({ data: { mimeTypes: IMAGE_MIME_TYPES } }),
+        cms.databaseAdapter.getAllImageStyles()
+    ]);
+    const files = allFiles.filter(isProcessableImage);
+    // Group existing styles by mediaFileId → set of style names
+    const existingByFile = new Map();
+    for (const s of allStyles) {
+        const fileId = s.mediaFileId;
+        if (!existingByFile.has(fileId))
+            existingByFile.set(fileId, new Set());
+        // We only have id/url/mediaFileId from getAllImageStyles, not name.
+        // So we count per-file total instead
+    }
+    // Count expected per-file and compare with existing count per-file
+    let expectedStyles = 0;
+    let missingStyles = 0;
+    // Count existing per mediaFileId
+    const existingCountByFile = new Map();
+    for (const s of allStyles) {
+        const fileId = s.mediaFileId;
+        existingCountByFile.set(fileId, (existingCountByFile.get(fileId) ?? 0) + 1);
+    }
+    for (const file of files) {
+        const expectedNames = getExpectedStyleNames(file);
+        const expected = expectedNames.length;
+        const existing = existingCountByFile.get(file.id) ?? 0;
+        expectedStyles += expected;
+        if (existing < expected) {
+            missingStyles += expected - existing;
+        }
+    }
+    return {
+        processableImages: files.length,
+        expectedStyles,
+        existingStyles: allStyles.length,
+        missingStyles
+    };
+}

package/dist/db-postgres/index.js

@@ -56,6 +56,142 @@ function buildJsonLikeConditions(dataLike) {
     });
     return conditions;
 }
+// Helper function to build JSON path conditions (ILIKE match, OR logic)
+function buildJsonILikeOrConditions(dataILikeOr) {
+    const conditions = [];
+    function processValue(value, path = []) {
+        if (value === null || value === undefined)
+            return;
+        if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
+            Object.entries(value).forEach(([key, nestedValue]) => {
+                processValue(nestedValue, [...path, key]);
+            });
+        }
+        else {
+            validateJsonPathKeys(path);
+            const jsonPath = path.join(',');
+            conditions.push(sql `${schema.entryVersionsTable.data}#>>'{${sql.raw(jsonPath)}}' ILIKE ${`%${String(value)}%`}`);
+        }
+    }
+    Object.entries(dataILikeOr).forEach(([key, value]) => {
+        processValue(value, [key]);
+    });
+    if (conditions.length === 0)
+        return undefined;
+    if (conditions.length === 1)
+        return conditions[0];
+    return sql `(${sql.join(conditions, sql ` OR `)})`;
+}
+// Raw SQL condition builders for CTE queries (use v.column / e.column aliases)
+function buildRawJsonConditions(dataValue) {
+    const conditions = [];
+    function processValue(value, path = []) {
+        if (value === null || value === undefined)
+            return;
+        if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
+            Object.entries(value).forEach(([key, nestedValue]) => {
+                processValue(nestedValue, [...path, key]);
+            });
+        }
+        else {
+            validateJsonPathKeys(path);
+            const jsonPath = path.join(',');
+            conditions.push(sql `v.data#>>'{${sql.raw(jsonPath)}}' = ${String(value)}`);
+        }
+    }
+    Object.entries(dataValue).forEach(([key, value]) => {
+        processValue(value, [key]);
+    });
+    return conditions;
+}
+function buildRawJsonLikeConditions(dataLike) {
+    const conditions = [];
+    function processValue(value, path = []) {
+        if (value === null || value === undefined)
+            return;
+        if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
+            Object.entries(value).forEach(([key, nestedValue]) => {
+                processValue(nestedValue, [...path, key]);
+            });
+        }
+        else {
+            validateJsonPathKeys(path);
+            const jsonPath = path.join(',');
+            conditions.push(sql `v.data#>>'{${sql.raw(jsonPath)}}' LIKE ${`%${String(value)}%`}`);
+        }
+    }
+    Object.entries(dataLike).forEach(([key, value]) => {
+        processValue(value, [key]);
+    });
+    return conditions;
+}
+function buildRawJsonILikeOrConditions(dataILikeOr) {
+    const conditions = [];
+    function processValue(value, path = []) {
+        if (value === null || value === undefined)
+            return;
+        if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
+            Object.entries(value).forEach(([key, nestedValue]) => {
+                processValue(nestedValue, [...path, key]);
+            });
+        }
+        else {
+            validateJsonPathKeys(path);
+            const jsonPath = path.join(',');
+            conditions.push(sql `v.data#>>'{${sql.raw(jsonPath)}}' ILIKE ${`%${String(value)}%`}`);
+        }
+    }
+    Object.entries(dataILikeOr).forEach(([key, value]) => {
+        processValue(value, [key]);
+    });
+    if (conditions.length === 0)
+        return undefined;
+    if (conditions.length === 1)
+        return conditions[0];
+    return sql `(${sql.join(conditions, sql ` OR `)})`;
+}
+function buildCteVersionConditions(options) {
+    const conditions = [sql `v.lang = ${options.language}`];
+    if (options.status === 'published') {
+        conditions.push(sql `v.published_at IS NOT NULL`);
+        conditions.push(sql `v.published_at <= NOW()`);
+    }
+    else if (options.status === 'draft') {
+        conditions.push(sql `v.published_at IS NULL`);
+    }
+    else if (options.status === 'scheduled') {
+        conditions.push(sql `v.published_at IS NOT NULL`);
+        conditions.push(sql `v.published_at > NOW()`);
+    }
+    if (options.dataValues) {
+        conditions.push(...buildRawJsonConditions(options.dataValues));
+    }
+    if (options.dataLike) {
+        conditions.push(...buildRawJsonLikeConditions(options.dataLike));
+    }
+    if (options.dataILikeOr) {
+        const orCondition = buildRawJsonILikeOrConditions(options.dataILikeOr);
+        if (orCondition)
+            conditions.push(orCondition);
+    }
+    return conditions;
+}
+function buildCteEntryConditions(options) {
+    const conditions = [];
+    if (options.status === 'archived') {
+        conditions.push(sql `e.archived_at IS NOT NULL`);
+    }
+    else {
+        conditions.push(sql `e.archived_at IS NULL`);
+    }
+    if (options.slug) {
+        conditions.push(sql `e.slug = ${options.slug}`);
+    }
+    if (options.ids && options.ids.length > 0) {
+        conditions.push(sql `e.id = ANY(${options.ids})`);
+    }
+    return conditions;
+}
 /** Hydrate tags onto raw media file rows */
 async function hydrateFileTags(db, files) {
     if (files.length === 0)
@@ -84,6 +220,48 @@ async function hydrateFileTags(db, files) {
     }
     return files.map((f) => ({ ...f, tags: fileTagMap.get(f.id) || [] }));
 }
+function buildMediaFileConditions(db, options) {
+    const conditions = [];
+    if (options.data) {
+        if (options.data.search) {
+            conditions.push(or(ilike(schema.mediaFilesTable.name, `%${options.data.search}%`), ilike(schema.mediaFilesTable.alt, `%${options.data.search}%`)));
+        }
+        if (options.data.ids) {
+            conditions.push(inArray(schema.mediaFilesTable.id, options.data.ids));
+        }
+        if (options.data.mimeTypes) {
+            const exact = options.data.mimeTypes.filter((t) => !t.endsWith('/*'));
+            const wildcards = options.data.mimeTypes.filter((t) => t.endsWith('/*'));
+            const mimeTypeConditions = wildcards.map((t) => ilike(schema.mediaFilesTable.mimeType, t.replace('*', '%')));
+            const typeConditions = wildcards.map((t) => {
+                const baseType = t.replace('/*', '');
+                return eq(schema.mediaFilesTable.type, baseType);
+            });
+            const mimeConditions = [
+                ...(exact.length ? [inArray(schema.mediaFilesTable.mimeType, exact)] : []),
+                ...mimeTypeConditions,
+                ...typeConditions
+            ];
+            if (mimeConditions.length) {
+                conditions.push(or(...mimeConditions));
+            }
+        }
+        if (options.data.tagIds && options.data.tagIds.length > 0) {
+            const fileIdsWithTags = db
+                .select({ fileId: schema.mediaFileTagsTable.fileId })
+                .from(schema.mediaFileTagsTable)
+                .where(inArray(schema.mediaFileTagsTable.tagId, options.data.tagIds));
+            conditions.push(inArray(schema.mediaFilesTable.id, fileIdsWithTags));
+        }
+        if (options.data.untagged) {
+            const fileIdsWithAnyTag = db
+                .select({ fileId: schema.mediaFileTagsTable.fileId })
+                .from(schema.mediaFileTagsTable);
+            conditions.push(sql `${schema.mediaFilesTable.id} NOT IN (${fileIdsWithAnyTag})`);
+        }
+    }
+    return conditions;
+}
 export function pg(config) {
     const client = postgres(config.databaseUrl);
     const db = drizzle(client, { schema });
@@ -142,6 +320,92 @@ export function pg(config) {
                 .where(and(...conditions));
             return result?.count ?? 0;
         },
+        getPaginatedEntries: async (options) => {
+            const versionWhereParts = buildCteVersionConditions(options);
+            const versionWhere = sql.join(versionWhereParts, sql ` AND `);
+            const entryWhereParts = buildCteEntryConditions(options);
+            const entryWhere = sql.join(entryWhereParts, sql ` AND `);
+            let orderClause;
+            if (options.dataOrderBy) {
+                const field = options.dataOrderBy.field;
+                if (!SAFE_JSON_KEY.test(field)) {
+                    throw new Error(`Invalid dataOrderBy field: "${field}"`);
+                }
+                const dir = options.dataOrderBy.direction === 'desc' ? 'DESC' : 'ASC';
+                orderClause = sql.raw(`m.data->>'${field}' ${dir}`);
+            }
+            else if (options.orderBy) {
+                const col = options.orderBy.column === 'sortOrder' ? 'sort_order' : options.orderBy.column === 'createdAt' ? 'created_at' : 'updated_at';
+                orderClause = sql.raw(`e.${col} ${options.orderBy.direction}`);
+            }
+            else {
+                orderClause = sql.raw(`e.sort_order ASC`);
+            }
+            const rows = await db.execute(sql `
+				WITH matched AS (
+					SELECT DISTINCT ON (v.entry_id)
+						v.*
+					FROM entry_version v
+					WHERE ${versionWhere}
+					ORDER BY v.entry_id, v.version_number DESC
+				)
+				SELECT
+					e.id AS e_id, e.slug AS e_slug, e.type AS e_type,
+					e.created_at AS e_created_at, e.updated_at AS e_updated_at,
+					e.archived_at AS e_archived_at, e.sort_order AS e_sort_order,
+					m.id AS v_id, m.entry_id AS v_entry_id, m.lang AS v_lang,
+					m.version_number AS v_version_number, m.data AS v_data,
+					m.created_at AS v_created_at, m.created_by AS v_created_by,
+					m.published_at AS v_published_at, m.published_by AS v_published_by
+				FROM entry e
+				INNER JOIN matched m ON e.id = m.entry_id
+				WHERE ${entryWhere}
+				ORDER BY ${orderClause}
+				LIMIT ${options.limit} OFFSET ${options.offset}
+			`);
+            return rows.map((row) => ({
+                entry: {
+                    id: row.e_id,
+                    slug: row.e_slug,
+                    type: row.e_type,
+                    createdAt: new Date(row.e_created_at),
+                    updatedAt: new Date(row.e_updated_at),
+                    archivedAt: row.e_archived_at ? new Date(row.e_archived_at) : null,
+                    sortOrder: row.e_sort_order
+                },
+                version: {
+                    id: row.v_id,
+                    entryId: row.v_entry_id,
+                    lang: row.v_lang,
+                    versionNumber: row.v_version_number,
+                    data: row.v_data,
+                    createdAt: new Date(row.v_created_at),
+                    createdBy: row.v_created_by,
+                    publishedAt: row.v_published_at ? new Date(row.v_published_at) : null,
+                    publishedBy: row.v_published_by
+                }
+            }));
+        },
+        countPaginatedEntries: async (options) => {
+            const versionWhereParts = buildCteVersionConditions(options);
+            const versionWhere = sql.join(versionWhereParts, sql ` AND `);
+            const entryWhereParts = buildCteEntryConditions(options);
+            const entryWhere = sql.join(entryWhereParts, sql ` AND `);
+            const [result] = await db.execute(sql `
+				WITH matched AS (
+					SELECT DISTINCT ON (v.entry_id)
+						v.entry_id
+					FROM entry_version v
+					WHERE ${versionWhere}
+					ORDER BY v.entry_id, v.version_number DESC
+				)
+				SELECT COUNT(*)::int AS count
+				FROM entry e
+				INNER JOIN matched m ON e.id = m.entry_id
+				WHERE ${entryWhere}
+			`);
+            return result?.count ?? 0;
+        },
         updateEntry: async ({ id, data }) => {
             return db.transaction(async (tx) => {
                 const [result] = await tx
@@ -182,7 +446,7 @@ export function pg(config) {
                     .values({
                     ...data,
                     versionNumber: data.versionNumber ??
-                        sql `COALESCE((SELECT MAX(version_number) FROM ${schema.entryVersionsTable} WHERE entry_id = ${data.entryId}), 0) + 1`
+                        sql `COALESCE((SELECT MAX(version_number) FROM ${schema.entryVersionsTable} WHERE entry_id = ${data.entryId} AND lang = ${data.lang}), 0) + 1`
                 })
                     .returning();
                 return newVersion;
@@ -195,13 +459,17 @@ export function pg(config) {
                     options.entryIds
                         ? inArray(schema.entryVersionsTable.entryId, options.entryIds)
                         : undefined,
-                    options.ids ? inArray(schema.entryVersionsTable.id, options.ids) : undefined
+                    options.ids ? inArray(schema.entryVersionsTable.id, options.ids) : undefined,
+                    options.lang ? eq(schema.entryVersionsTable.lang, options.lang) : undefined
                 ].filter(Boolean);
                 const jsonConditions = options.dataValues ? buildJsonConditions(options.dataValues) : [];
                 const jsonLikeConditions = options.dataLike
                     ? buildJsonLikeConditions(options.dataLike)
                     : [];
-                const allConditions = [...baseConditions, ...jsonConditions, ...jsonLikeConditions];
+                const jsonILikeOrCondition = options.dataILikeOr
+                    ? buildJsonILikeOrConditions(options.dataILikeOr)
+                    : undefined;
+                const allConditions = [...baseConditions, ...jsonConditions, ...jsonLikeConditions, ...(jsonILikeOrCondition ? [jsonILikeOrCondition] : [])];
                 if (allConditions.length > 0) {
                     query.where(and(...allConditions));
                 }
@@ -351,48 +619,46 @@ export function pg(config) {
             await db.delete(schema.mediaFilesTable).where(inArray(schema.mediaFilesTable.id, ids));
         },
         getMediaFiles: async (options) => {
-            const conditions = [];
-            if (options.data) {
-                if (options.data.search) {
-                    conditions.push(or(ilike(schema.mediaFilesTable.name, `%${options.data.search}%`), ilike(schema.mediaFilesTable.alt, `%${options.data.search}%`)));
-                }
-                if (options.data.ids) {
-                    conditions.push(inArray(schema.mediaFilesTable.id, options.data.ids));
-                }
-                if (options.data.mimeTypes) {
-                    const exact = options.data.mimeTypes.filter((t) => !t.endsWith('/*'));
-                    const wildcards = options.data.mimeTypes.filter((t) => t.endsWith('/*'));
-                    const mimeTypeConditions = wildcards.map((t) => ilike(schema.mediaFilesTable.mimeType, t.replace('*', '%')));
-                    // Fallback to type field for files with null mimeType
-                    const typeConditions = wildcards.map((t) => {
-                        const baseType = t.replace('/*', '');
-                        return eq(schema.mediaFilesTable.type, baseType);
-                    });
-                    const mimeConditions = [
-                        ...(exact.length ? [inArray(schema.mediaFilesTable.mimeType, exact)] : []),
-                        ...mimeTypeConditions,
-                        ...typeConditions
-                    ];
-                    if (mimeConditions.length) {
-                        conditions.push(or(...mimeConditions));
-                    }
-                }
-                if (options.data.tagIds && options.data.tagIds.length > 0) {
-                    const fileIdsWithTags = db
-                        .select({ fileId: schema.mediaFileTagsTable.fileId })
-                        .from(schema.mediaFileTagsTable)
-                        .where(inArray(schema.mediaFileTagsTable.tagId, options.data.tagIds));
-                    conditions.push(inArray(schema.mediaFilesTable.id, fileIdsWithTags));
-                }
-            }
+            const conditions = buildMediaFileConditions(db, options);
             const query = db
                 .select()
                 .from(schema.mediaFilesTable)
                 .where(and(...conditions.filter(Boolean)))
                 .orderBy(desc(schema.mediaFilesTable.createdAt));
+            if (options.data.limit != null) {
+                query.limit(options.data.limit);
+            }
+            if (options.data.offset != null) {
+                query.offset(options.data.offset);
+            }
             const rawFiles = await query;
             return hydrateFileTags(db, rawFiles);
         },
+        countMediaFiles: async (options) => {
+            const conditions = buildMediaFileConditions(db, options);
+            const [result] = await db
+                .select({ count: count() })
+                .from(schema.mediaFilesTable)
+                .where(and(...conditions.filter(Boolean)));
+            return result?.count ?? 0;
+        },
+        getMediaTagsWithCounts: async () => {
+            const rows = await db
+                .select({
+                id: schema.mediaTagsTable.id,
+                name: schema.mediaTagsTable.name,
+                color: schema.mediaTagsTable.color,
+                count: count(schema.mediaFileTagsTable.fileId)
+            })
+                .from(schema.mediaTagsTable)
+                .leftJoin(schema.mediaFileTagsTable, eq(schema.mediaTagsTable.id, schema.mediaFileTagsTable.tagId))
+                .groupBy(schema.mediaTagsTable.id, schema.mediaTagsTable.name, schema.mediaTagsTable.color)
+                .orderBy(schema.mediaTagsTable.name);
+            return rows.map((r) => ({
+                tag: { id: r.id, name: r.name, color: r.color },
+                count: r.count
+            }));
+        },
         getMediaFile: async (options) => {
             const query = db.select().from(schema.mediaFilesTable);
             if (options.data) {

package/dist/db-postgres/schema/entry.d.ts

@@ -55,49 +55,6 @@ export declare const entriesTable: import("drizzle-orm/pg-core/table", { with: {
         }, {}, {
             $type: "collection" | "singleton";
         }>;
-        availableLocales: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
-            name: "available_locales";
-            tableName: "entry";
-            dataType: "array";
-            columnType: "PgArray";
-            data: string[];
-            driverParam: string | string[];
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: import("drizzle-orm/column", { with: { "resolution-mode": "require" } }).Column<{
-                name: "available_locales";
-                tableName: "entry";
-                dataType: "string";
-                columnType: "PgText";
-                data: string;
-                driverParam: string;
-                notNull: false;
-                hasDefault: false;
-                isPrimaryKey: false;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: [string, ...string[]];
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {}>;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            size: undefined;
-            baseBuilder: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumnBuilder<{
-                name: "available_locales";
-                dataType: "string";
-                columnType: "PgText";
-                data: string;
-                enumValues: [string, ...string[]];
-                driverParam: string;
-            }, {}, {}, import("drizzle-orm/column-builder", { with: { "resolution-mode": "require" } }).ColumnBuilderExtraConfig>;
-        }>;
         createdAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
             name: "created_at";
             tableName: "entry";
@@ -149,57 +106,6 @@ export declare const entriesTable: import("drizzle-orm/pg-core/table", { with: {
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-        publishedAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
-            name: "published_at";
-            tableName: "entry";
-            dataType: "date";
-            columnType: "PgTimestamp";
-            data: Date;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        publishedVersionId: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
-            name: "published_version_id";
-            tableName: "entry";
-            dataType: "string";
-            columnType: "PgUUID";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        publishedBy: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
-            name: "published_by";
-            tableName: "entry";
-            dataType: "string";
-            columnType: "PgText";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
         sortOrder: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
             name: "sort_order";
             tableName: "entry";

package/dist/db-postgres/schema/entry.js

@@ -1,18 +1,12 @@
 import { integer, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
-import { entryVersionsTable } from './entryVersion.js';
 export const entriesTable = pgTable('entry', {
     id: uuid('id').primaryKey().defaultRandom(),
     slug: text('slug').notNull(),
     type: text('type').notNull().$type(),
-    availableLocales: text('available_locales').array(),
     // Metadane
     createdAt: timestamp('created_at').defaultNow().notNull(),
     updatedAt: timestamp('updated_at').defaultNow().notNull(),
     archivedAt: timestamp('archived_at'), // soft delete / archiwum
-    // Publish state
-    publishedAt: timestamp('published_at'),
-    publishedVersionId: uuid('published_version_id').references(() => entryVersionsTable.id, { onDelete: 'set null' }),
-    publishedBy: text('published_by'),
     // Manual ordering
     sortOrder: integer('sort_order')
 });

package/dist/db-postgres/schema/entryVersion.d.ts

@@ -37,6 +37,23 @@ export declare const entryVersionsTable: import("drizzle-orm/pg-core/table", { w
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        lang: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "lang";
+            tableName: "entry_version";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         versionNumber: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
             name: "version_number";
             tableName: "entry_version";