@xleddyl/nuxt-cms 0.1.56 → 0.1.58

package/dist/runtime/server/utils/db-d1.js

@@ -21,6 +21,11 @@ export function useDb() {
   if (!_db) _db = drizzle(useD1Binding());
   return _db;
 }
+export const cmsDialect = "sqlite";
 export function withTransaction(fn) {
   return fn(useDb());
 }
+export function runBatch(build) {
+  const db = useDb();
+  return db.batch(build(db));
+}

package/dist/runtime/server/utils/db-libsql.d.ts

@@ -3,5 +3,7 @@ export declare function useDb(): import("drizzle-orm/libsql").LibSQLDatabase<Rec
 };
 type Db = ReturnType<typeof useDb>;
 export type CmsDb = Db | Parameters<Parameters<Db['transaction']>[0]>[0];
+export declare const cmsDialect: 'sqlite' | 'postgres';
 export declare function withTransaction<T>(fn: (db: CmsDb) => Promise<T>): Promise<T>;
+export declare function runBatch(build: (db: CmsDb) => PromiseLike<unknown>[]): Promise<unknown[]>;
 export {};

package/dist/runtime/server/utils/db-libsql.js

@@ -20,6 +20,11 @@ export function useDb() {
   }
   return _db;
 }
+export const cmsDialect = "sqlite";
 export function withTransaction(fn) {
   return useDb().transaction((tx) => fn(tx));
 }
+export function runBatch(build) {
+  const db = useDb();
+  return db.batch(build(db));
+}

package/dist/runtime/server/utils/db-postgres.d.ts

@@ -3,5 +3,7 @@ export declare function useDb(): import("drizzle-orm/node-postgres").NodePgDatab
 };
 type Db = ReturnType<typeof useDb>;
 export type CmsDb = Db | Parameters<Parameters<Db['transaction']>[0]>[0];
+export declare const cmsDialect: 'sqlite' | 'postgres';
 export declare function withTransaction<T>(fn: (db: CmsDb) => Promise<T>): Promise<T>;
+export declare function runBatch(build: (db: CmsDb) => PromiseLike<unknown>[]): Promise<unknown[]>;
 export {};

package/dist/runtime/server/utils/db-postgres.js

@@ -16,6 +16,14 @@ export function useDb() {
   }
   return _db;
 }
+export const cmsDialect = "postgres";
 export function withTransaction(fn) {
   return useDb().transaction((tx) => fn(tx));
 }
+export function runBatch(build) {
+  return withTransaction(async (db) => {
+    const results = [];
+    for (const statement of build(db)) results.push(await statement);
+    return results;
+  });
+}

package/dist/runtime/server/utils/db-sqlite.d.ts

@@ -3,4 +3,6 @@ export declare function useDb(): import("drizzle-orm/better-sqlite3").BetterSQLi
     $client: Database.Database;
 };
 export type CmsDb = ReturnType<typeof useDb>;
+export declare const cmsDialect: 'sqlite' | 'postgres';
 export declare function withTransaction<T>(fn: (db: CmsDb) => Promise<T>): Promise<T>;
+export declare function runBatch(build: (db: CmsDb) => PromiseLike<unknown>[]): Promise<unknown[]>;

package/dist/runtime/server/utils/db-sqlite.js

@@ -16,6 +16,7 @@ export function useDb() {
   }
   return _db;
 }
+export const cmsDialect = "sqlite";
 let txQueue = Promise.resolve();
 export function withTransaction(fn) {
   const db = useDb();
@@ -34,3 +35,10 @@ export function withTransaction(fn) {
   });
   return run;
 }
+export function runBatch(build) {
+  return withTransaction(async (db) => {
+    const results = [];
+    for (const statement of build(db)) results.push(await statement);
+    return results;
+  });
+}

package/dist/runtime/server/utils/graphql.js

@@ -38,6 +38,7 @@ import {
   typeName
 } from "../../shared/graphql-sdl.js";
 import { useMediaIndex } from "./media-index.js";
+import { readPages } from "./page-storage.js";
 import { getContentI18n, resolveTable, tableColumns } from "./registry.js";
 const MAX_LIMIT = 100;
 const DEFAULT_LIMIT = 50;
@@ -322,14 +323,12 @@ export function buildCmsSchema() {
     if (entry.kind === "page") {
       queryResolvers[name] = async (_, args) => {
         const locale = resolveLocaleArg(args.locale);
-        const table = tableFor(name);
-        const rows = await useDb().select().from(table).orderBy(asc(tableColumns(table).path));
+        const rows = await readPages(name, entry, tableFor(name), { orderByPath: true });
         return rows.map((row) => localizeRow(entry, row, locale));
       };
       queryResolvers[`${name}ByPath`] = async (_, args) => {
         const locale = resolveLocaleArg(args.locale);
-        const table = tableFor(name);
-        const [row] = await useDb().select().from(table).where(eq(tableColumns(table).path, args.path)).limit(1);
+        const [row] = await readPages(name, entry, tableFor(name), { path: args.path });
         return row ? localizeRow(entry, row, locale) : null;
       };
       continue;

package/dist/runtime/server/utils/libsql-migrations.d.ts

@@ -0,0 +1,16 @@
+export interface LibsqlMigration {
+    sql: string[];
+    folderMillis: number;
+    hash: string;
+}
+export interface LibsqlStatement {
+    sql: string;
+    args: (string | number)[];
+}
+export interface LibsqlMigrationClient {
+    execute: (statement: string) => Promise<{
+        rows: ArrayLike<unknown>[];
+    }>;
+    batch: (statements: LibsqlStatement[], mode: 'write') => Promise<unknown>;
+}
+export declare function applyLibsqlMigrations(client: LibsqlMigrationClient, migrations: LibsqlMigration[]): Promise<number>;

package/dist/runtime/server/utils/libsql-migrations.js

@@ -0,0 +1,35 @@
+const MIGRATIONS_TABLE = "__drizzle_migrations";
+async function lastAppliedMillis(client) {
+  const { rows } = await client.execute(
+    `SELECT id, hash, created_at FROM "${MIGRATIONS_TABLE}" ORDER BY created_at DESC LIMIT 1`
+  );
+  const createdAt = rows[0]?.[2];
+  return createdAt == null ? null : Number(createdAt);
+}
+export async function applyLibsqlMigrations(client, migrations) {
+  if (!migrations.length) return 0;
+  await client.execute(
+    `CREATE TABLE IF NOT EXISTS "${MIGRATIONS_TABLE}" (id SERIAL PRIMARY KEY, hash text NOT NULL, created_at numeric)`
+  );
+  const lastApplied = await lastAppliedMillis(client);
+  const pending = migrations.filter(
+    (migration) => lastApplied == null || lastApplied < migration.folderMillis
+  );
+  if (!pending.length) return 0;
+  const statements = pending.flatMap((migration) => [
+    ...migration.sql.filter((statement) => statement.trim()).map((sql) => ({ sql, args: [] })),
+    {
+      sql: `INSERT INTO "${MIGRATIONS_TABLE}" ("hash", "created_at") VALUES (?, ?)`,
+      args: [migration.hash, migration.folderMillis]
+    }
+  ]);
+  try {
+    await client.batch(statements, "write");
+  } catch (error) {
+    const latest = Math.max(...migrations.map((migration) => migration.folderMillis));
+    const appliedNow = await lastAppliedMillis(client).catch(() => null);
+    if (appliedNow != null && appliedNow >= latest) return 0;
+    throw error;
+  }
+  return pending.length;
+}

package/dist/runtime/server/utils/media-check.d.ts

@@ -0,0 +1,2 @@
+import type { FieldConfig } from '../../shared/index.js';
+export declare function assertMediaExists(fields: Record<string, FieldConfig>, values: Record<string, unknown>): Promise<void>;

package/dist/runtime/server/utils/media-check.js

@@ -0,0 +1,20 @@
+import { useDb } from "#cms-db";
+import { cms_media } from "#cms-tables";
+import { useRuntimeConfig } from "#imports";
+import { useMediaIndex } from "./media-index.js";
+import { assertKnownMedia, mediaKeysInTable, mediaReferences } from "./media-references.js";
+async function mediaLookup() {
+  const { media } = useRuntimeConfig().cms;
+  if (media.storage !== "local") {
+    return (keys) => mediaKeysInTable(useDb(), cms_media, keys);
+  }
+  const index = await useMediaIndex();
+  if (index.source.kind === "none") return null;
+  return async (keys) => new Set(keys.filter((key) => index.get(key)));
+}
+export async function assertMediaExists(fields, values) {
+  const references = mediaReferences(fields, values);
+  if (!references.length) return;
+  const lookup = await mediaLookup();
+  if (lookup) await assertKnownMedia(references, lookup);
+}

package/dist/runtime/server/utils/media-references.d.ts

@@ -0,0 +1,10 @@
+import type { BaseSQLiteDatabase, SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { FieldConfig } from '../../shared/index.js';
+export interface MediaReference {
+    field: string;
+    key: string;
+}
+export type MediaLookup = (keys: string[]) => Promise<Set<string>>;
+export declare function mediaReferences(fields: Record<string, FieldConfig>, values: Record<string, unknown>): MediaReference[];
+export declare function assertKnownMedia(references: MediaReference[], lookup: MediaLookup): Promise<void>;
+export declare function mediaKeysInTable(db: Pick<BaseSQLiteDatabase<'sync' | 'async', unknown>, 'select'>, table: SQLiteTable, keys: string[]): Promise<Set<string>>;

package/dist/runtime/server/utils/media-references.js

@@ -0,0 +1,50 @@
+import { inArray } from "drizzle-orm";
+import { createError } from "h3";
+const LOOKUP_CHUNK = 90;
+function mediaKeysOf(value) {
+  if (typeof value === "string") return value ? [value] : [];
+  if (!value || typeof value !== "object") return [];
+  return Object.values(value).filter(
+    (key) => typeof key === "string" && key !== ""
+  );
+}
+export function mediaReferences(fields, values) {
+  const references = [];
+  for (const [key, field] of Object.entries(fields)) {
+    const value = values[key];
+    if (field.type === "media") {
+      for (const mediaKey of mediaKeysOf(value)) references.push({ field: key, key: mediaKey });
+      continue;
+    }
+    if (field.type !== "blocks" || !Array.isArray(value)) continue;
+    value.forEach((item, index) => {
+      const block = item ? field.blocks?.[String(item.type)] : void 0;
+      for (const [blockFieldKey, blockField] of Object.entries(block?.fields ?? {})) {
+        if (blockField.type !== "media") continue;
+        for (const mediaKey of mediaKeysOf(item?.[blockFieldKey])) {
+          references.push({ field: `${key}[${index}].${blockFieldKey}`, key: mediaKey });
+        }
+      }
+    });
+  }
+  return references;
+}
+export async function assertKnownMedia(references, lookup) {
+  if (!references.length) return;
+  const known = await lookup([...new Set(references.map((reference) => reference.key))]);
+  const missing = references.filter((reference) => !known.has(reference.key));
+  if (!missing.length) return;
+  throw createError({
+    statusCode: 400,
+    statusMessage: `Media not found in the library: ${missing.map((reference) => `'${reference.key}' (${reference.field})`).join(", ")}`
+  });
+}
+export async function mediaKeysInTable(db, table, keys) {
+  const column = table.key;
+  const found = /* @__PURE__ */ new Set();
+  for (let index = 0; index < keys.length; index += LOOKUP_CHUNK) {
+    const rows = await db.select({ key: column }).from(table).where(inArray(column, keys.slice(index, index + LOOKUP_CHUNK)));
+    for (const row of rows) found.add(row.key);
+  }
+  return found;
+}

package/dist/runtime/server/utils/migrate.d.ts

@@ -5,4 +5,5 @@ export interface CmsMigration {
     hash: string;
 }
 export declare function runCmsMigrations(db: unknown): Promise<void>;
+export declare function runLibsqlMigrations(db: unknown): Promise<void>;
 export declare function runD1Migrations(binding: unknown): Promise<void>;

package/dist/runtime/server/utils/migrate.js

@@ -1,6 +1,7 @@
 import cmsConfig from "#cms-config";
 import { migrations as bundledMigrations } from "#cms-migrations";
 import { useRuntimeConfig } from "#imports";
+import { applyLibsqlMigrations } from "./libsql-migrations.js";
 const MIGRATIONS_TABLE = "__drizzle_migrations";
 async function readMigrations(migrationsDir) {
   if (import.meta.dev) {
@@ -28,6 +29,12 @@ export async function runCmsMigrations(db) {
   const { dialect, session } = db;
   await dialect.migrate(migrations, session, {});
 }
+export async function runLibsqlMigrations(db) {
+  const migrations = await pendingMigrations();
+  if (!migrations.length) return;
+  const { $client } = db;
+  await applyLibsqlMigrations($client, migrations);
+}
 export async function runD1Migrations(binding) {
   const migrations = await pendingMigrations();
   if (!migrations.length) return;

package/dist/runtime/server/utils/page-rows.d.ts

@@ -0,0 +1,51 @@
+import type { SQL } from 'drizzle-orm';
+import type { BaseSQLiteDatabase, SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { CmsEntry, CmsPageRoute } from '../../shared/index.js';
+export type PageDialect = 'sqlite' | 'postgres';
+export type PageDb = Pick<BaseSQLiteDatabase<'sync' | 'async', unknown>, 'select' | 'insert' | 'delete'>;
+export interface PageTables {
+    page: SQLiteTable;
+    fields: SQLiteTable;
+    media: SQLiteTable;
+}
+export interface PageFieldRow {
+    pageId: string;
+    key: string;
+    position: number;
+    value: string;
+}
+export interface PageMediaRow {
+    pageId: string;
+    key: string;
+    position: number;
+    mediaKey: string;
+}
+export interface EncodedPage {
+    columns: Record<string, unknown>;
+    fields: PageFieldRow[];
+    media: PageMediaRow[];
+    fieldKeys: string[];
+    mediaKeys: string[];
+}
+type Row = Record<string, unknown>;
+export declare const PAGE_BLOCK_TYPE_KEY = "_type";
+export declare function pageBlockKey(fieldKey: string, blockFieldKey: string): string;
+export declare function encodePageRows(entry: CmsEntry, pageId: string, values: Row): EncodedPage;
+export declare function decodePageRow(entry: CmsEntry, row: Row): Row;
+export declare function decodePageRows(entry: CmsEntry, rows: Row[]): Row[];
+export declare function pageSelection(dialect: PageDialect, tables: PageTables): {
+    $fields: SQL<unknown>;
+    $media: SQL<unknown>;
+};
+export declare function selectPages(db: PageDb, dialect: PageDialect, tables: PageTables): import("drizzle-orm/sqlite-core").SQLiteSelectBase<string, "async" | "sync", unknown, {
+    $fields: SQL<unknown>;
+    $media: SQL<unknown>;
+}, "partial", Record<string, "not-null">, true, never, {
+    $fields: unknown;
+    $media: unknown;
+}[], {
+    $fields: import("drizzle-orm").DrizzleTypeError<"You cannot reference this field without assigning it an alias first - use `.as(<alias>)`">;
+    $media: import("drizzle-orm").DrizzleTypeError<"You cannot reference this field without assigning it an alias first - use `.as(<alias>)`">;
+}>;
+export declare function pageWriteStatements(db: PageDb, dialect: PageDialect, tables: PageTables, entry: CmsEntry, route: Pick<CmsPageRoute, 'key' | 'path'>, values: Row): PromiseLike<unknown>[];
+export {};

package/dist/runtime/server/utils/page-rows.js

@@ -0,0 +1,223 @@
+import { and, eq, getTableColumns, getTableName, inArray, sql } from "drizzle-orm";
+import {
+  PAGE_PATH_FIELD,
+  isMultiSelect,
+  isTranslatableField,
+  isTranslatableMediaField,
+  pageAllFields,
+  pageRowFields
+} from "../../shared/index.js";
+export const PAGE_BLOCK_TYPE_KEY = "_type";
+const FIELDS_SELECTION = "$fields";
+const MEDIA_SELECTION = "$media";
+const INSERT_CHUNK = 20;
+const KEY_CHUNK = 90;
+const PLAIN_STRING_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "richtext",
+  "email",
+  "slug",
+  "date",
+  "select",
+  "relation"
+]);
+function columnsOf(table) {
+  return table;
+}
+function isPlainString(field) {
+  return !!field && PLAIN_STRING_TYPES.has(field.type) && !isTranslatableField(field) && !isMultiSelect(field);
+}
+function parseJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function encodeValue(field, value) {
+  return isPlainString(field) ? String(value) : JSON.stringify(value);
+}
+function decodeValue(field, raw) {
+  return isPlainString(field) ? raw : parseJson(raw);
+}
+function encodeMedia(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function decodeBlockMedia(field, raw) {
+  return isTranslatableMediaField(field) && raw.startsWith("{") ? parseJson(raw) : raw;
+}
+export function pageBlockKey(fieldKey, blockFieldKey) {
+  return `${fieldKey}.${blockFieldKey}`;
+}
+function blockOwnedKeys(key, field) {
+  const fields = /* @__PURE__ */ new Set([pageBlockKey(key, PAGE_BLOCK_TYPE_KEY)]);
+  const media = /* @__PURE__ */ new Set();
+  for (const block of Object.values(field.blocks ?? {})) {
+    for (const [blockFieldKey, blockField] of Object.entries(block.fields)) {
+      const blockKey = pageBlockKey(key, blockFieldKey);
+      if (blockField.type === "media") media.add(blockKey);
+      else fields.add(blockKey);
+    }
+  }
+  return { fields: [...fields], media: [...media] };
+}
+export function encodePageRows(entry, pageId, values) {
+  const rowFields = pageRowFields(entry);
+  const encoded = { columns: {}, fields: [], media: [], fieldKeys: [], mediaKeys: [] };
+  const pushField = (key, position, value) => encoded.fields.push({ pageId, key, position, value });
+  const pushMedia = (key, position, value) => encoded.media.push({ pageId, key, position, mediaKey: encodeMedia(value) });
+  for (const [key, value] of Object.entries(values)) {
+    const field = rowFields[key];
+    if (!field) {
+      encoded.columns[key] = value;
+      continue;
+    }
+    if (field.type === "blocks") {
+      const owned = blockOwnedKeys(key, field);
+      encoded.fieldKeys.push(...owned.fields);
+      encoded.mediaKeys.push(...owned.media);
+      if (!Array.isArray(value)) continue;
+      value.forEach((item, position) => {
+        const type = String(item.type);
+        const block = field.blocks?.[type];
+        pushField(pageBlockKey(key, PAGE_BLOCK_TYPE_KEY), position, type);
+        for (const [blockFieldKey, blockValue] of Object.entries(item)) {
+          if (blockFieldKey === "type" || blockValue == null) continue;
+          const blockField = block?.fields[blockFieldKey];
+          const blockKey = pageBlockKey(key, blockFieldKey);
+          if (blockField?.type === "media") pushMedia(blockKey, position, blockValue);
+          else pushField(blockKey, position, encodeValue(blockField, blockValue));
+        }
+      });
+      continue;
+    }
+    if (field.type === "media") {
+      encoded.mediaKeys.push(key);
+      if (value != null) pushMedia(key, 0, value);
+      continue;
+    }
+    encoded.fieldKeys.push(key);
+    if (value != null) pushField(key, 0, encodeValue(field, value));
+  }
+  return encoded;
+}
+function parseChildren(value) {
+  if (value == null) return [];
+  const rows = typeof value === "string" ? parseJson(value) : value;
+  return Array.isArray(rows) ? rows : [];
+}
+function indexChildren(rows) {
+  const index = /* @__PURE__ */ new Map();
+  for (const [key, position, value] of rows) {
+    if (key == null || value == null) continue;
+    let positions = index.get(key);
+    if (!positions) {
+      positions = /* @__PURE__ */ new Map();
+      index.set(key, positions);
+    }
+    positions.set(Number(position), String(value));
+  }
+  return index;
+}
+function decodeBlocks(key, field, fields, media) {
+  const types = fields.get(pageBlockKey(key, PAGE_BLOCK_TYPE_KEY));
+  if (!types?.size) return null;
+  return [...types.entries()].sort(([a], [b]) => a - b).map(([position, type]) => {
+    const item = { type };
+    for (const [blockFieldKey, blockField] of Object.entries(
+      field.blocks?.[type]?.fields ?? {}
+    )) {
+      const blockKey = pageBlockKey(key, blockFieldKey);
+      if (blockField.type === "media") {
+        const raw2 = media.get(blockKey)?.get(position);
+        item[blockFieldKey] = raw2 == null ? null : decodeBlockMedia(blockField, raw2);
+        continue;
+      }
+      const raw = fields.get(blockKey)?.get(position);
+      item[blockFieldKey] = raw == null ? null : decodeValue(blockField, raw);
+    }
+    return item;
+  });
+}
+function decodeRowField(key, field, fields, media) {
+  if (field.type === "blocks") return decodeBlocks(key, field, fields, media);
+  if (field.type === "media") return media.get(key)?.get(0) ?? null;
+  const raw = fields.get(key)?.get(0);
+  return raw == null ? null : decodeValue(field, raw);
+}
+export function decodePageRow(entry, row) {
+  const rowFields = pageRowFields(entry);
+  const fields = indexChildren(parseChildren(row[FIELDS_SELECTION]));
+  const media = indexChildren(parseChildren(row[MEDIA_SELECTION]));
+  const result = { id: row.id, [PAGE_PATH_FIELD]: row[PAGE_PATH_FIELD] };
+  for (const [key, field] of Object.entries(pageAllFields(entry))) {
+    result[key] = Object.hasOwn(rowFields, key) ? decodeRowField(key, field, fields, media) : row[key] ?? null;
+  }
+  for (const [key, value] of Object.entries(row)) {
+    if (key === FIELDS_SELECTION || key === MEDIA_SELECTION || Object.hasOwn(result, key))
+      continue;
+    result[key] = value;
+  }
+  return result;
+}
+export function decodePageRows(entry, rows) {
+  return rows.map((row) => decodePageRow(entry, row));
+}
+function qualified(table, column) {
+  return sql`${sql.identifier(getTableName(table))}.${sql.identifier(column.name)}`;
+}
+function childAggregate(dialect, page, table, valueKey) {
+  const columns = columnsOf(table);
+  const owner = qualified(table, columns.pageId);
+  const key = qualified(table, columns.key);
+  const position = qualified(table, columns.position);
+  const value = qualified(table, columns[valueKey]);
+  const pageId = qualified(page, columnsOf(page).id);
+  const from = sql.identifier(getTableName(table));
+  return dialect === "postgres" ? sql`(select coalesce(json_agg(json_build_array(${key}, ${position}, ${value})), '[]'::json) from ${from} where ${owner} = ${pageId})` : sql`(select json_group_array(json_array(${key}, ${position}, ${value})) from ${from} where ${owner} = ${pageId})`;
+}
+export function pageSelection(dialect, tables) {
+  return {
+    ...getTableColumns(tables.page),
+    [FIELDS_SELECTION]: childAggregate(dialect, tables.page, tables.fields, "value"),
+    [MEDIA_SELECTION]: childAggregate(dialect, tables.page, tables.media, "mediaKey")
+  };
+}
+export function selectPages(db, dialect, tables) {
+  return db.select(pageSelection(dialect, tables)).from(tables.page).$dynamic();
+}
+function chunks(items, size) {
+  const out = [];
+  for (let index = 0; index < items.length; index += size) {
+    out.push(items.slice(index, index + size));
+  }
+  return out;
+}
+export function pageWriteStatements(db, dialect, tables, entry, route, values) {
+  const encoded = encodePageRows(entry, route.key, values);
+  const pageId = columnsOf(tables.page).id;
+  const fieldColumns = columnsOf(tables.fields);
+  const mediaColumns = columnsOf(tables.media);
+  const set = encoded.columns;
+  const statements = [
+    db.insert(tables.page).values({ ...set, id: route.key, [PAGE_PATH_FIELD]: route.path }).onConflictDoUpdate({ target: pageId, set })
+  ];
+  for (const keys of chunks(encoded.fieldKeys, KEY_CHUNK)) {
+    statements.push(
+      db.delete(tables.fields).where(and(eq(fieldColumns.pageId, route.key), inArray(fieldColumns.key, keys)))
+    );
+  }
+  for (const keys of chunks(encoded.mediaKeys, KEY_CHUNK)) {
+    statements.push(
+      db.delete(tables.media).where(and(eq(mediaColumns.pageId, route.key), inArray(mediaColumns.key, keys)))
+    );
+  }
+  for (const rows of chunks(encoded.fields, INSERT_CHUNK)) {
+    statements.push(db.insert(tables.fields).values(rows));
+  }
+  for (const rows of chunks(encoded.media, INSERT_CHUNK)) {
+    statements.push(db.insert(tables.media).values(rows));
+  }
+  statements.push(selectPages(db, dialect, tables).where(eq(pageId, route.key)).limit(1));
+  return statements;
+}

package/dist/runtime/server/utils/page-storage.d.ts

@@ -0,0 +1,11 @@
+import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { CmsEntry, CmsPageRoute } from '../../shared/index.js';
+type Row = Record<string, unknown>;
+export interface PageReadOptions {
+    id?: string;
+    path?: string;
+    orderByPath?: boolean;
+}
+export declare function readPages(name: string, entry: CmsEntry, table: SQLiteTable, options?: PageReadOptions): Promise<Row[]>;
+export declare function writePage(name: string, entry: CmsEntry, table: SQLiteTable, route: Pick<CmsPageRoute, 'key' | 'path'>, set: Row): Promise<Row>;
+export {};

package/dist/runtime/server/utils/page-storage.js

@@ -0,0 +1,42 @@
+import { asc, eq } from "drizzle-orm";
+import { createError } from "h3";
+import { cmsDialect, runBatch, useDb } from "#cms-db";
+import * as cmsTables from "#cms-tables";
+import { PAGE_PATH_FIELD, pageFieldsTableName, pageMediaTableName } from "../../shared/index.js";
+import { decodePageRows, pageWriteStatements, selectPages } from "./page-rows.js";
+import { idColumn, tableColumns } from "./registry.js";
+function childTable(name) {
+  const table = cmsTables[name];
+  if (!table) throw createError({ statusCode: 500, statusMessage: `No table: ${name}` });
+  return table;
+}
+function pageTables(name, table) {
+  return {
+    page: table,
+    fields: childTable(pageFieldsTableName(name)),
+    media: childTable(pageMediaTableName(name))
+  };
+}
+function pageFilter(table, options) {
+  if (options.id !== void 0) return eq(idColumn(table), options.id);
+  if (options.path !== void 0) return eq(tableColumns(table)[PAGE_PATH_FIELD], options.path);
+  return void 0;
+}
+export async function readPages(name, entry, table, options = {}) {
+  const db = useDb();
+  const where = pageFilter(table, options);
+  const single = options.id !== void 0 || options.path !== void 0;
+  const rows = selectPages(db, cmsDialect, pageTables(name, table));
+  if (where) rows.where(where);
+  if (options.orderByPath) rows.orderBy(asc(tableColumns(table)[PAGE_PATH_FIELD]));
+  if (single) rows.limit(1);
+  const result = await rows;
+  return decodePageRows(entry, result);
+}
+export async function writePage(name, entry, table, route, set) {
+  const tables = pageTables(name, table);
+  const results = await runBatch(
+    (db) => pageWriteStatements(db, cmsDialect, tables, entry, route, set)
+  );
+  return decodePageRows(entry, results.at(-1))[0];
+}

package/dist/runtime/shared/index.d.ts

@@ -96,6 +96,7 @@ export declare function translatableBlockFieldKeys(block: BlockConfig): string[]
 export declare function hasTranslatableBlockFields(field: FieldConfig): boolean;
 export declare function localizeBlock(field: FieldConfig, item: unknown, locale: string, defaultLocale: string): unknown;
 export declare function localizeBlocks(field: FieldConfig, value: unknown, locale: string, defaultLocale: string): unknown;
+export declare const CMS_GRAPHQL_BATCH_LIMIT = 20;
 export type CmsEntryKind = 'collection' | 'single' | 'page';
 export interface CmsPageRoute {
     path: string;
@@ -116,6 +117,7 @@ export interface CmsEntry {
     labels?: Record<string, string>;
     overrides?: Record<string, Record<string, FieldConfig | null>>;
     pages?: CmsPageRoute[];
+    columns?: string[];
     tabs?: CmsTab[];
     table?: CmsTable;
 }
@@ -134,6 +136,10 @@ export declare function pageRouteOf(entry: CmsEntry, key: string): CmsPageRoute
 export declare function pageOverrideFields(entry: CmsEntry, path: string): Record<string, FieldConfig | null>;
 export declare function pageFields(entry: CmsEntry, path: string): Record<string, FieldConfig>;
 export declare function pageAllFields(entry: CmsEntry): Record<string, FieldConfig>;
+export declare function pageColumnFields(entry: CmsEntry): Record<string, FieldConfig>;
+export declare function pageRowFields(entry: CmsEntry): Record<string, FieldConfig>;
+export declare function pageFieldsTableName(name: string): string;
+export declare function pageMediaTableName(name: string): string;
 type EntryLike = Pick<CmsEntry, 'fields'> & Partial<Pick<CmsEntry, 'kind' | 'overrides'>>;
 export declare function entryFieldsFor(entry: EntryLike, path?: string): Record<string, FieldConfig>;
 export declare function typeName(name: string): string;
@@ -228,6 +234,7 @@ export interface CmsPageInput extends CmsEntryInputBase {
     order?: string[];
     labels?: Record<string, string>;
     overrides?: Record<string, Record<string, CmsFieldInput | null>>;
+    columns?: string[];
 }
 export type CmsEntryInput = CmsCollectionInput | CmsSingleInput | CmsPageInput;
 export type CmsConfigInput = Record<string, CmsEntryInput>;