@xleddyl/nuxt-cms 0.2.1 → 0.2.3

package/dist/runtime/server/api/media-folder.patch.js

@@ -1,20 +1,20 @@
-import { eq } from "drizzle-orm";
 import { createError, defineEventHandler, readValidatedBody } from "h3";
 import { z } from "zod";
-import { useDb } from "#cms-db";
+import { runBatch } from "#cms-db";
 import { cms_media } from "#cms-tables";
 import {
-  isMediaFolderMarker,
   isWithinMediaFolder,
   MEDIA_FOLDER_MAX_DEPTH,
   mediaFolderDepth,
+  mediaFolderMarkerKey,
   mediaFolderSegments,
   normalizeMediaFolder,
   rebaseMediaFolder
 } from "../../shared/index.js";
 import { useMediaStorage } from "../utils/media.js";
-import { mediaRowsInFolder, writeMediaFolderMarker } from "../utils/media-folders.js";
+import { mediaRowsInFolder } from "../utils/media-folders.js";
 import { requireAdmin } from "../utils/require-admin.js";
+import { mediaFolderRenameStatements, planMediaFolderRename } from "../utils/write-statements.js";
 const bodySchema = z.object({
   from: z.string().min(1).max(255),
   to: z.string().min(1).max(255)
@@ -50,19 +50,13 @@ export default defineEventHandler(async (event) => {
   if (rebased.some((row) => mediaFolderDepth(row.target) > MEDIA_FOLDER_MAX_DEPTH)) {
     throw tooDeep();
   }
-  const db = useDb();
-  const fileFolders = /* @__PURE__ */ new Map();
-  for (const row of rebased) {
-    if (!isMediaFolderMarker(row.key)) fileFolders.set(row.folder, row.target);
+  const plan = planMediaFolderRename(rebased);
+  for (const folder of plan.markers) {
+    await store.write(mediaFolderMarkerKey(folder), new Uint8Array(), "application/x-empty");
   }
-  for (const [folder, target] of fileFolders) {
-    await db.update(cms_media).set({ folder: target }).where(eq(cms_media.folder, folder));
-  }
-  for (const row of rebased) {
-    if (!isMediaFolderMarker(row.key)) continue;
-    await writeMediaFolderMarker(store, row.target);
-    await store.remove(row.key);
-    await db.delete(cms_media).where(eq(cms_media.key, row.key));
+  await runBatch((db) => mediaFolderRenameStatements(db, cms_media, plan));
+  for (const key of plan.staleMarkers) {
+    await store.remove(key);
   }
   return { folder: to, moved: rows.length };
 });

package/dist/runtime/server/api/media-move.post.js

@@ -1,7 +1,7 @@
 import { and, inArray, not, like } from "drizzle-orm";
 import { defineEventHandler, readValidatedBody } from "h3";
 import { z } from "zod";
-import { useDb } from "#cms-db";
+import { runBatch } from "#cms-db";
 import { cms_media } from "#cms-tables";
 import { MEDIA_FOLDER_MARKER, normalizeMediaFolder } from "../../shared/index.js";
 import { objectKeySchema } from "../../shared/validation.js";
@@ -17,12 +17,16 @@ export default defineEventHandler(async (event) => {
   useMediaStorage(event);
   const { keys, folder } = await readValidatedBody(event, bodySchema.parse);
   const target = normalizeMediaFolder(folder);
-  let moved = 0;
-  for (const chunk of keyChunks([...new Set(keys)])) {
-    const rows = await useDb().update(cms_media).set({ folder: target }).where(
-      and(inArray(cms_media.key, chunk), not(like(cms_media.key, `%/${MEDIA_FOLDER_MARKER}`)))
-    ).returning({ key: cms_media.key });
-    moved += rows.length;
-  }
+  const results = await runBatch(
+    (db) => keyChunks([...new Set(keys)]).map(
+      (chunk) => db.update(cms_media).set({ folder: target }).where(
+        and(
+          inArray(cms_media.key, chunk),
+          not(like(cms_media.key, `%/${MEDIA_FOLDER_MARKER}`))
+        )
+      ).returning({ key: cms_media.key })
+    )
+  );
+  const moved = results.reduce((total, rows) => total + rows.length, 0);
   return { folder: target, moved };
 });

package/dist/runtime/server/api/media.delete.js

@@ -17,7 +17,7 @@ export default defineEventHandler(async (event) => {
   if (!row || isMediaFolderMarker(key)) {
     throw createError({ statusCode: 404, statusMessage: "Media not found" });
   }
-  await store.remove(key);
   await db.delete(cms_media).where(eq(cms_media.key, key));
+  await store.remove(key);
   return { ok: true };
 });

package/dist/runtime/server/api/media.post.js

@@ -4,6 +4,7 @@ import { z } from "zod";
 import { useDb } from "#cms-db";
 import { cms_media } from "#cms-tables";
 import { normalizeMediaFolder } from "../../shared/index.js";
+import { nowTimestamp } from "../../shared/timestamps.js";
 import { objectKeySchema } from "../../shared/validation.js";
 import { requireMediaFilePath } from "../utils/media-fs.js";
 import {
@@ -41,6 +42,6 @@ export default defineEventHandler(async (event) => {
     alt: body.alt ?? null,
     folder: normalizeMediaFolder(body.folder)
   };
-  const [row] = await useDb().insert(cms_media).values(values).onConflictDoUpdate({ target: cms_media.key, set: values }).returning();
+  const [row] = await useDb().insert(cms_media).values({ ...values, createdAt: nowTimestamp() }).onConflictDoUpdate({ target: cms_media.key, set: values }).returning();
   return toMediaItem(row, publicUrl);
 });

package/dist/runtime/server/api/media.put.js

@@ -4,6 +4,7 @@ import { z } from "zod";
 import { useDb } from "#cms-db";
 import { cms_media } from "#cms-tables";
 import { normalizeMediaFolder } from "../../shared/index.js";
+import { nowTimestamp } from "../../shared/timestamps.js";
 import { objectKeySchema } from "../../shared/validation.js";
 import { useMediaIndex } from "../utils/media-index.js";
 import { assertMediaWritable, toMediaItem, useMediaConfig } from "../utils/media.js";
@@ -29,7 +30,7 @@ export default defineEventHandler(async (event) => {
       throw createError({ statusCode: 404, statusMessage: "Media not found" });
     }
     const alt = body.alt ?? null;
-    await useDb().insert(cms_media).values({ key: body.key, alt }).onConflictDoUpdate({ target: cms_media.key, set: { alt } });
+    await useDb().insert(cms_media).values({ key: body.key, alt, createdAt: nowTimestamp() }).onConflictDoUpdate({ target: cms_media.key, set: { alt } });
     return toMediaItem({ ...file, alt, createdAt: null }, publicUrl);
   }
   assertMediaWritable(media);

package/dist/runtime/server/plugins/migrate-sqlite.js

@@ -1,5 +1,5 @@
 import { useDb } from "../utils/db-sqlite.js";
-import { runCmsMigrations } from "../utils/migrate.js";
+import { runSqliteMigrations } from "../utils/migrate.js";
 export default async () => {
-  await runCmsMigrations(useDb());
+  await runSqliteMigrations(useDb());
 };

package/dist/runtime/server/routes/auth/login.post.js

@@ -12,25 +12,27 @@ const credentialsSchema = z.object({
   email: z.string().trim().min(1).max(254),
   password: z.string().min(1).max(256)
 });
-const RATE_WINDOW_MS = 15 * 6e4;
-const RATE_MAX_FAILURES = 10;
-const RATE_GLOBAL_MAX_FAILURES = 100;
+const RATE_LOCK_MS = 5 * 6e4;
+const RATE_MAX_FAILURES = 5;
 const RATE_PRUNE_EVERY = 200;
-const GLOBAL_KEY = "global";
 let writesSincePrune = 0;
 function rateStorage() {
   return useStorage("cms:login-rate");
 }
-function rateKey(ip) {
-  return ip.replace(/[^a-z0-9]/gi, "-");
+function rateKey(kind, value) {
+  return `${kind}:${value.replace(/[^a-z0-9]/gi, "-")}`;
 }
 async function readEntry(key, now) {
   const entry = await rateStorage().getItem(key);
   return entry && entry.resetAt > now ? entry : null;
 }
-async function recordFailure(key, now) {
-  const current = await readEntry(key, now) ?? { count: 0, resetAt: now + RATE_WINDOW_MS };
+function isLocked(entry) {
+  return !!entry && entry.count >= RATE_MAX_FAILURES;
+}
+async function recordAttempt(key, now) {
+  const current = await readEntry(key, now) ?? { count: 0, resetAt: now + RATE_LOCK_MS };
   current.count++;
+  if (current.count >= RATE_MAX_FAILURES) current.resetAt = now + RATE_LOCK_MS;
   await rateStorage().setItem(key, current, {
     ttl: Math.ceil((current.resetAt - now) / 1e3)
   });
@@ -47,6 +49,15 @@ async function prune(now) {
     })
   );
 }
+async function clearAttempts(keys) {
+  await Promise.all(keys.map((key) => rateStorage().removeItem(key)));
+}
+function tooManyAttempts() {
+  return createError({
+    statusCode: 429,
+    statusMessage: "Too many failed attempts, try again in 5 minutes"
+  });
+}
 function safeEqual(a, b) {
   const hashA = createHash("sha256").update(a).digest();
   const hashB = createHash("sha256").update(b).digest();
@@ -54,34 +65,29 @@ function safeEqual(a, b) {
 }
 export default defineEventHandler(async (event) => {
   assertSameOrigin(event);
-  const ip = rateKey(getRequestIP(event, { xForwardedFor: true }) ?? "unknown");
   const now = Date.now();
-  const [attempts, globalFailures] = await Promise.all([
-    readEntry(ip, now),
-    readEntry(GLOBAL_KEY, now)
-  ]);
-  if (globalFailures && globalFailures.count >= RATE_GLOBAL_MAX_FAILURES || attempts && attempts.count >= RATE_MAX_FAILURES) {
-    throw createError({
-      statusCode: 429,
-      statusMessage: "Too many failed attempts, try again later"
-    });
-  }
   const body = await readValidatedBody(event, credentialsSchema.parse);
   const email = body.email.toLowerCase();
+  const keys = [
+    rateKey("ip", getRequestIP(event, { xForwardedFor: true }) ?? "unknown"),
+    rateKey("email", email)
+  ];
+  const entries = await Promise.all(keys.map((key) => readEntry(key, now)));
+  if (entries.some(isLocked)) throw tooManyAttempts();
+  await Promise.all([...keys.map((key) => recordAttempt(key, now)), prune(now)]);
   const { adminEmail, adminPassword } = useRuntimeConfig(event).cms;
   const superAdmin = !!adminEmail && !!adminPassword && safeEqual(email, adminEmail.toLowerCase()) && safeEqual(body.password, adminPassword);
   if (superAdmin) {
-    await rateStorage().removeItem(ip);
+    await clearAttempts(keys);
     await replaceUserSession(event, { user: { email, role: "superadmin" } });
     return { loggedIn: true };
   }
   const row = await findUserByEmail(email);
   const passwordOk = row ? await verifyPassword(row.passwordHash, body.password) : await verifyNothing(body.password);
   if (!row || !passwordOk) {
-    await Promise.all([recordFailure(ip, now), recordFailure(GLOBAL_KEY, now), prune(now)]);
     throw createError({ statusCode: 401, statusMessage: "Invalid credentials" });
   }
-  await rateStorage().removeItem(ip);
+  await clearAttempts(keys);
   await useDb().update(cms_users).set({ lastLoginAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq(cms_users.id, row.id));
   await replaceUserSession(event, { user: sessionUserFor(row) });
   return { loggedIn: true };

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

@@ -8,6 +8,5 @@ export declare function useDb(): import("drizzle-orm/d1").DrizzleD1Database<Reco
 type Db = ReturnType<typeof useDb>;
 export type CmsDb = Db;
 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-d1.js

@@ -22,10 +22,9 @@ export function useDb() {
   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));
+  const statements = build(db);
+  if (!statements.length) return Promise.resolve([]);
+  return db.batch(statements);
 }

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

@@ -4,6 +4,5 @@ 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

@@ -21,10 +21,9 @@ 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));
+  const statements = build(db);
+  if (!statements.length) return Promise.resolve([]);
+  return db.batch(statements);
 }

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

@@ -4,6 +4,5 @@ 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

@@ -17,11 +17,8 @@ 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) => {
+  return useDb().transaction(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

@@ -4,5 +4,4 @@ export declare function useDb(): import("drizzle-orm/better-sqlite3").BetterSQLi
 };
 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

@@ -18,14 +18,15 @@ export function useDb() {
 }
 export const cmsDialect = "sqlite";
 let txQueue = Promise.resolve();
-export function withTransaction(fn) {
+export function runBatch(build) {
   const db = useDb();
   const run = txQueue.then(async () => {
     await db.run(sql`begin immediate`);
     try {
-      const result = await fn(db);
+      const results = [];
+      for (const statement of build(db)) results.push(await statement);
       await db.run(sql`commit`);
-      return result;
+      return results;
     } catch (error) {
       await db.run(sql`rollback`);
       throw error;
@@ -35,10 +36,3 @@ 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

@@ -20,6 +20,8 @@ import { cmsDialect, useDb } from "#cms-db";
 import * as cmsTables from "#cms-tables";
 import { useRuntimeConfig } from "#imports";
 import {
+  CONTENT_SLUG_FIELD,
+  CONTENT_PUBLISHED_AT_FIELD,
   decodeTranslatableMedia,
   entryFieldsFor,
   hasTranslatableBlockFields,
@@ -29,6 +31,7 @@ import {
   mediaPublicUrl,
   mediaTypeFor,
   pickTranslatedMedia,
+  publicBlocks,
   translatableFieldKeys
 } from "../../shared/index.js";
 import {
@@ -37,9 +40,11 @@ import {
   renderGraphqlSdl,
   typeName
 } from "../../shared/graphql-sdl.js";
+import { normalizeTimestampFields } from "../../shared/timestamps.js";
 import { useMediaIndex } from "./media-index.js";
 import { readPages } from "./page-storage.js";
 import { getContentI18n, resolveTable, tableColumns } from "./registry.js";
+import { visibilityConditions } from "./visibility.js";
 const MAX_LIMIT = 100;
 const DEFAULT_LIMIT = 50;
 const LOCALE = Symbol("locale");
@@ -84,9 +89,7 @@ function tableFor(name) {
   return table;
 }
 function publishedFilter(entry, table) {
-  if (!entry.drafts) return [];
-  const status = tableColumns(table).status;
-  return status ? [eq(status, "published")] : [];
+  return visibilityConditions(entry, tableColumns(table));
 }
 function localeOf(parent) {
   return parent[LOCALE] ?? getContentI18n().defaultLocale;
@@ -103,7 +106,7 @@ function resolveLocaleArg(locale) {
 }
 function localizeRow(entry, row, locale) {
   const { defaultLocale } = getContentI18n();
-  const result = { ...row, [LOCALE]: locale };
+  const result = normalizeTimestampFields({ ...row, [LOCALE]: locale });
   const fields = entryFieldsFor(entry);
   for (const key of translatableFieldKeys(entry)) {
     if (isTranslatableMediaField(fields[key])) {
@@ -115,8 +118,9 @@ function localizeRow(entry, row, locale) {
     result[key] = value?.[locale] ?? value?.[defaultLocale] ?? null;
   }
   for (const [key, field] of Object.entries(fields)) {
-    if (isPrivateField(field) || !hasTranslatableBlockFields(field)) continue;
-    result[key] = localizeBlocks(field, result[key], locale, defaultLocale);
+    if (isPrivateField(field) || field.type !== "blocks") continue;
+    const visible = publicBlocks(field, result[key]);
+    result[key] = hasTranslatableBlockFields(field) ? localizeBlocks(field, visible, locale, defaultLocale) : visible;
   }
   return result;
 }
@@ -161,7 +165,7 @@ function filterConditions(table, filters) {
   }
   return conditions;
 }
-function sortOrder(table, sort) {
+function sortOrder(entry, table, sort) {
   const order = [];
   for (const part of sort ?? []) {
     const column = columnFor(table, part.field);
@@ -169,7 +173,10 @@ function sortOrder(table, sort) {
     order.push(part.direction === "desc" ? desc(column) : asc(column));
   }
   if (!order.length) {
-    const fallback = tableColumns(table).createdAt ?? tableColumns(table).id;
+    const columns = tableColumns(table);
+    const published = entry.kind === "content" ? columns[CONTENT_PUBLISHED_AT_FIELD] : void 0;
+    if (published) order.push(desc(published));
+    const fallback = columns.createdAt ?? columns.id;
     if (fallback) order.push(desc(fallback));
   }
   return order;
@@ -349,7 +356,7 @@ export function buildCmsSchema() {
       const where = [...publishedFilter(entry, table), ...filterConditions(table, args.filters)];
       const limit = Math.min(MAX_LIMIT, Math.max(0, args.limit ?? DEFAULT_LIMIT));
       const offset = Math.max(0, args.offset ?? 0);
-      const rows = await useDb().select().from(table).where(where.length ? and(...where) : void 0).orderBy(...sortOrder(table, args.sort)).limit(limit).offset(offset);
+      const rows = await useDb().select().from(table).where(where.length ? and(...where) : void 0).orderBy(...sortOrder(entry, table, args.sort)).limit(limit).offset(offset);
       return rows.map((row) => localizeRow(entry, row, locale));
     };
     queryResolvers[`${name}ById`] = async (_, args) => {
@@ -358,6 +365,15 @@ export function buildCmsSchema() {
       const [row] = await useDb().select().from(table).where(and(eq(tableColumns(table).id, args.id), ...publishedFilter(entry, table))).limit(1);
       return row ? localizeRow(entry, row, locale) : null;
     };
+    if (entry.kind === "content") {
+      queryResolvers[`${name}BySlug`] = async (_, args) => {
+        const locale = resolveLocaleArg(args.locale);
+        const table = tableFor(name);
+        const slug = tableColumns(table)[CONTENT_SLUG_FIELD];
+        const [row] = await useDb().select().from(table).where(and(eq(slug, args.slug), ...publishedFilter(entry, table))).limit(1);
+        return row ? localizeRow(entry, row, locale) : null;
+      };
+    }
     queryResolvers[`${name}Count`] = async (_, args) => {
       const table = tableFor(name);
       const where = [...publishedFilter(entry, table), ...filterConditions(table, args.filters)];

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

@@ -12,5 +12,6 @@ export interface LibsqlMigrationClient {
         rows: ArrayLike<unknown>[];
     }>;
     batch: (statements: LibsqlStatement[], mode: 'write') => Promise<unknown>;
+    migrate: (statements: LibsqlStatement[]) => Promise<unknown>;
 }
 export declare function applyLibsqlMigrations(client: LibsqlMigrationClient, migrations: LibsqlMigration[]): Promise<number>;

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

@@ -24,7 +24,7 @@ export async function applyLibsqlMigrations(client, migrations) {
     }
   ]);
   try {
-    await client.batch(statements, "write");
+    await client.migrate(statements);
   } catch (error) {
     const latest = Math.max(...migrations.map((migration) => migration.folderMillis));
     const appliedNow = await lastAppliedMillis(client).catch(() => null);

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

@@ -1,24 +1,21 @@
-import { eq, inArray, or, sql } from "drizzle-orm";
-import { useDb } from "#cms-db";
+import { eq, or, sql } from "drizzle-orm";
+import { runBatch, useDb } from "#cms-db";
 import { cms_media } from "#cms-tables";
 import { mediaFolderMarkerKey } from "../../shared/index.js";
-const KEY_CHUNK = 90;
+import { nowTimestamp } from "../../shared/timestamps.js";
+import {
+  chunks,
+  KEY_CHUNK,
+  mediaDeleteStatements,
+  mediaFolderMarkerValues
+} from "./write-statements.js";
 function escapeLike(value) {
   return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
 }
 export async function writeMediaFolderMarker(store, folder) {
-  const key = mediaFolderMarkerKey(folder);
-  await store.write(key, new Uint8Array(), "application/x-empty");
-  const values = {
-    key,
-    mime: "application/x-empty",
-    size: 0,
-    width: null,
-    height: null,
-    alt: null,
-    folder
-  };
-  await useDb().insert(cms_media).values(values).onConflictDoUpdate({ target: cms_media.key, set: values });
+  await store.write(mediaFolderMarkerKey(folder), new Uint8Array(), "application/x-empty");
+  const values = mediaFolderMarkerValues(folder);
+  await useDb().insert(cms_media).values({ ...values, createdAt: nowTimestamp() }).onConflictDoUpdate({ target: cms_media.key, set: values });
 }
 export function mediaRowsInFolder(folder) {
   return useDb().select({ key: cms_media.key, folder: cms_media.folder }).from(cms_media).where(
@@ -29,17 +26,11 @@ export function mediaRowsInFolder(folder) {
   );
 }
 export async function deleteMediaRows(store, keys) {
+  await runBatch((db) => mediaDeleteStatements(db, cms_media, keys));
   for (const key of keys) {
     await store.remove(key);
   }
-  for (const chunk of keyChunks(keys)) {
-    await useDb().delete(cms_media).where(inArray(cms_media.key, chunk));
-  }
 }
 export function keyChunks(keys) {
-  const chunks = [];
-  for (let index = 0; index < keys.length; index += KEY_CHUNK) {
-    chunks.push(keys.slice(index, index + KEY_CHUNK));
-  }
-  return chunks;
+  return chunks(keys, KEY_CHUNK);
 }

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

@@ -2,6 +2,7 @@ import { AwsClient } from "aws4fetch";
 import { createError } from "h3";
 import { useRuntimeConfig } from "#imports";
 import { formatFileSize, mediaPublicUrl, mediaTypeFor } from "../../shared/index.js";
+import { normalizeTimestamp } from "../../shared/timestamps.js";
 import { removeMediaFile, writeMediaFile } from "./media-fs.js";
 const UPLOAD_TYPE_PREFIXES = ["image/", "video/", "audio/", "font/"];
 const UPLOAD_TYPE_BLOCKLIST = /* @__PURE__ */ new Set(["image/svg+xml"]);
@@ -147,6 +148,7 @@ export function useMediaStorage(event) {
 export function toMediaItem(row, publicUrl) {
   return {
     ...row,
+    createdAt: normalizeTimestamp(row.createdAt),
     type: mediaTypeFor(row.mime, row.key),
     url: publicUrl(row.key)
   };

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

@@ -5,5 +5,6 @@ export interface CmsMigration {
     hash: string;
 }
 export declare function runCmsMigrations(db: unknown): Promise<void>;
+export declare function runSqliteMigrations(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,7 +1,10 @@
+import { sql } from "drizzle-orm";
 import cmsConfig from "#cms-config";
 import { migrations as bundledMigrations } from "#cms-migrations";
+import * as cmsTables from "#cms-tables";
 import { useRuntimeConfig } from "#imports";
 import { applyLibsqlMigrations } from "./libsql-migrations.js";
+import { backfillTimestamps } from "./timestamps.js";
 const MIGRATIONS_TABLE = "__drizzle_migrations";
 async function readMigrations(migrationsDir) {
   if (import.meta.dev) {
@@ -29,11 +32,36 @@ export async function runCmsMigrations(db) {
   const { dialect, session } = db;
   await dialect.migrate(migrations, session, {});
 }
+export async function runSqliteMigrations(db) {
+  const migrations = await pendingMigrations();
+  if (!migrations.length) return;
+  const { dialect, session, $client } = db;
+  $client.pragma("foreign_keys = OFF");
+  try {
+    await dialect.migrate(migrations, session, {});
+  } finally {
+    $client.pragma("foreign_keys = ON");
+  }
+  const sqlite = db;
+  await backfillTimestamps(cmsTables, {
+    select: async (query) => sqlite.all(sql.raw(query)),
+    write: async (statements) => {
+      for (const statement of statements) sqlite.run(sql.raw(statement));
+    }
+  });
+}
 export async function runLibsqlMigrations(db) {
   const migrations = await pendingMigrations();
   if (!migrations.length) return;
   const { $client } = db;
   await applyLibsqlMigrations($client, migrations);
+  await backfillTimestamps(cmsTables, {
+    select: async (query) => Array.from((await $client.execute(query)).rows),
+    write: (statements) => $client.batch(
+      statements.map((statement) => ({ sql: statement, args: [] })),
+      "write"
+    )
+  });
 }
 export async function runD1Migrations(binding) {
   const migrations = await pendingMigrations();
@@ -55,4 +83,8 @@ export async function runD1Migrations(binding) {
     );
   }
   if (batch.length) await d1.batch(batch);
+  await backfillTimestamps(cmsTables, {
+    select: async (query) => (await d1.prepare(query).all()).results,
+    write: (statements) => d1.batch(statements.map((statement) => d1.prepare(statement)))
+  });
 }

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

@@ -9,6 +9,9 @@ export declare function idColumn(table: SQLiteTable): AnySQLiteColumn;
 export declare function withUpdatedAt(table: SQLiteTable, values: Record<string, unknown>): {
     [x: string]: unknown;
 };
+export declare function withTimestamps(table: SQLiteTable, values: Record<string, unknown>): {
+    [x: string]: unknown;
+};
 export declare function getRegistryEntry(event: H3Event): {
     name: string;
     entry: CmsEntry;
@@ -20,4 +23,5 @@ export declare function buildValidator(entry: CmsEntry, path?: string): z.ZodObj
 export declare function requirePageRoute(entry: CmsEntry, key: string): CmsPageRoute;
 export declare function encodeColumnValues(entry: CmsEntry, values: Record<string, unknown>): Record<string, unknown>;
 export declare function decodeRows<T extends Record<string, unknown>>(entry: CmsEntry, rows: T[]): T[];
+export declare function withContentDefaults(entry: CmsEntry, values: Record<string, unknown>): Record<string, unknown>;
 export declare function parseId(event: H3Event): string;