@xleddyl/nuxt-cms 0.2.1 → 0.2.2

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

@@ -37,6 +37,7 @@ 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";
@@ -103,7 +104,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])) {

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;

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

@@ -9,6 +9,7 @@ import {
   pageFields,
   pageRouteOf
 } from "../../shared/index.js";
+import { normalizeTimestampFields, nowTimestamp } from "../../shared/timestamps.js";
 import { buildEntrySchema } from "../../shared/validation.js";
 let contentI18n;
 export function getContentI18n() {
@@ -30,9 +31,16 @@ export function idColumn(table) {
 }
 export function withUpdatedAt(table, values) {
   const set = { ...values };
-  if ("updatedAt" in table) set.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if ("updatedAt" in table) set.updatedAt = nowTimestamp();
   return set;
 }
+export function withTimestamps(table, values) {
+  const now = nowTimestamp();
+  const stamped = { ...values };
+  if ("createdAt" in table) stamped.createdAt ??= now;
+  if ("updatedAt" in table) stamped.updatedAt ??= now;
+  return stamped;
+}
 export function getRegistryEntry(event) {
   const name = getRouterParam(event, "collection");
   const config = cmsConfig;
@@ -58,6 +66,7 @@ export function encodeColumnValues(entry, values) {
   return encodeEntryTranslatableMedia(entry, values);
 }
 export function decodeRows(entry, rows) {
+  for (const row of rows) normalizeTimestampFields(row);
   return decodeEntryTranslatableMedia(entry, rows, getContentI18n().defaultLocale);
 }
 export function parseId(event) {

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

@@ -8,7 +8,7 @@ export declare function splitRelationValues(entry: CmsEntry, body: Row): {
     lists: Record<string, string[]>;
 };
 export declare function assertRelationTargets(entry: CmsEntry, lists: Record<string, string[]>): Promise<void>;
-export declare function saveManyToMany(db: CmsDb, name: string, sourceId: string, lists: Record<string, string[]>): Promise<void>;
+export declare function manyToManyStatements(db: CmsDb, name: string, sourceId: string, lists: Record<string, string[]>): PromiseLike<unknown>[];
 export declare function relationTitles(db: CmsDb, entry: CmsEntry, rows: Row[]): Promise<Record<string, Record<string, unknown>>>;
 export declare function attachManyToMany<T extends Row>(db: CmsDb, name: string, entry: CmsEntry, rows: T[]): Promise<T[]>;
 export {};

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

@@ -1,10 +1,11 @@
-import { asc, eq, inArray } from "drizzle-orm";
+import { asc, inArray } from "drizzle-orm";
 import { createError } from "h3";
 import cmsConfig from "#cms-config";
 import { useDb } from "#cms-db";
 import * as cmsTables from "#cms-tables";
 import { entryFieldsFor } from "../../shared/index.js";
 import { resolveTable, tableColumns } from "./registry.js";
+import { joinWriteStatements } from "./write-statements.js";
 function manyToManyKeys(entry) {
   return Object.entries(entryFieldsFor(entry)).filter(([, field]) => field.type === "relation" && field.cardinality === "many-to-many").map(([key]) => key);
 }
@@ -50,14 +51,10 @@ export async function assertRelationTargets(entry, lists) {
     }
   }
 }
-export async function saveManyToMany(db, name, sourceId, lists) {
-  for (const [key, ids] of Object.entries(lists)) {
-    const join = joinTable(name, key);
-    await db.delete(join.table).where(eq(join.sourceId, sourceId));
-    if (ids.length) {
-      await db.insert(join.table).values(ids.map((targetId, position) => ({ sourceId, targetId, position })));
-    }
-  }
+export function manyToManyStatements(db, name, sourceId, lists) {
+  return Object.entries(lists).flatMap(
+    ([key, ids]) => joinWriteStatements(db, joinTable(name, key), sourceId, ids)
+  );
 }
 export async function relationTitles(db, entry, rows) {
   const config = cmsConfig;

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

@@ -0,0 +1,12 @@
+export interface TimestampColumn {
+    table: string;
+    column: string;
+}
+export interface TimestampBackfillDriver {
+    select: (query: string) => Promise<unknown[]>;
+    write: (statements: string[]) => Promise<unknown>;
+}
+export declare function timestampColumns(tables: Record<string, unknown>): TimestampColumn[];
+export declare function timestampProbeQuery(columns: TimestampColumn[]): string;
+export declare function timestampBackfillStatement({ table, column }: TimestampColumn): string;
+export declare function backfillTimestamps(tables: Record<string, unknown>, driver: TimestampBackfillDriver): Promise<number>;

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

@@ -0,0 +1,48 @@
+import { is } from "drizzle-orm";
+import { SQLiteTable, getTableConfig } from "drizzle-orm/sqlite-core";
+import { SQLITE_ISO_FORMAT } from "../../shared/timestamps.js";
+const TIMESTAMP_COLUMNS = /* @__PURE__ */ new Set(["created_at", "updated_at"]);
+function quoteIdentifier(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function legacyCondition(column) {
+  const target = quoteIdentifier(column);
+  return `${target} NOT LIKE '%T%' AND strftime('${SQLITE_ISO_FORMAT}', ${target}) IS NOT NULL`;
+}
+export function timestampColumns(tables) {
+  const found = [];
+  for (const table of Object.values(tables)) {
+    if (!is(table, SQLiteTable)) continue;
+    const { name, columns } = getTableConfig(table);
+    for (const column of columns) {
+      if (TIMESTAMP_COLUMNS.has(column.name)) found.push({ table: name, column: column.name });
+    }
+  }
+  return found;
+}
+export function timestampProbeQuery(columns) {
+  return columns.map(
+    ({ table, column }, index) => `SELECT ${index} AS target WHERE EXISTS (SELECT 1 FROM ${quoteIdentifier(
+      table
+    )} WHERE ${legacyCondition(column)})`
+  ).join(" UNION ALL ");
+}
+export function timestampBackfillStatement({ table, column }) {
+  const target = quoteIdentifier(column);
+  return `UPDATE ${quoteIdentifier(
+    table
+  )} SET ${target} = strftime('${SQLITE_ISO_FORMAT}', ${target}) WHERE ${legacyCondition(column)}`;
+}
+function targetIndex(row) {
+  if (Array.isArray(row)) return Number(row[0]);
+  return Number(row.target);
+}
+export async function backfillTimestamps(tables, driver) {
+  const columns = timestampColumns(tables);
+  if (!columns.length) return 0;
+  const rows = await driver.select(timestampProbeQuery(columns));
+  const stale = rows.map((row) => columns[targetIndex(row)]).filter((column) => !!column);
+  if (!stale.length) return 0;
+  await driver.write(stale.map(timestampBackfillStatement));
+  return stale.length;
+}

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

@@ -1,6 +1,7 @@
 import { eq } from "drizzle-orm";
 import { useDb } from "#cms-db";
 import { cms_users } from "#cms-tables";
+import { normalizeTimestamp } from "../../shared/timestamps.js";
 export async function findUserByEmail(email) {
   const [row] = await useDb().select().from(cms_users).where(eq(cms_users.email, email.toLowerCase()));
   return row;
@@ -28,7 +29,7 @@ export function toAccount(row) {
     email: row.email,
     name: row.name ?? null,
     role: row.role,
-    lastLoginAt: row.lastLoginAt ?? null,
-    createdAt: String(row.createdAt)
+    lastLoginAt: normalizeTimestamp(row.lastLoginAt ?? null),
+    createdAt: String(normalizeTimestamp(row.createdAt))
   };
 }

package/dist/runtime/server/utils/write-statements.d.ts

@@ -0,0 +1,33 @@
+import type { AnySQLiteColumn, BaseSQLiteDatabase, SQLiteTable } from 'drizzle-orm/sqlite-core';
+export type WriteDb = Pick<BaseSQLiteDatabase<'sync' | 'async', unknown>, 'insert' | 'update' | 'delete'>;
+export interface JoinTable {
+    table: SQLiteTable;
+    sourceId: AnySQLiteColumn;
+    targetId: AnySQLiteColumn;
+    position: AnySQLiteColumn;
+}
+export interface RebasedMediaRow {
+    key: string;
+    folder: string | null;
+    target: string | null;
+}
+export interface MediaFolderRename {
+    folders: [string, string | null][];
+    markers: string[];
+    staleMarkers: string[];
+}
+export declare const KEY_CHUNK = 90;
+export declare function chunks<T>(items: T[], size: number): T[][];
+export declare function joinWriteStatements(db: WriteDb, join: JoinTable, sourceId: string, ids: string[]): PromiseLike<unknown>[];
+export declare function mediaFolderMarkerValues(folder: string): {
+    key: string;
+    mime: string;
+    size: number;
+    width: null;
+    height: null;
+    alt: null;
+    folder: string;
+};
+export declare function planMediaFolderRename(rows: RebasedMediaRow[]): MediaFolderRename;
+export declare function mediaFolderRenameStatements(db: WriteDb, table: SQLiteTable, plan: MediaFolderRename): PromiseLike<unknown>[];
+export declare function mediaDeleteStatements(db: WriteDb, table: SQLiteTable, keys: string[]): PromiseLike<unknown>[];