@xleddyl/nuxt-cms 0.2.0 → 0.2.2

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/require-admin.d.ts

@@ -1,7 +1,5 @@
 import type { H3Event } from 'h3';
 import type { CmsSessionUser } from '../../shared/index.js';
-import { assertSameOrigin } from './same-origin.js';
-export { assertSameOrigin };
 export declare function isSuperAdminEmail(event: H3Event, email: string): boolean;
 export declare function requireAdmin(event: H3Event): Promise<CmsSessionUser>;
 export declare function requireSuperAdmin(event: H3Event): Promise<CmsSessionUser>;

package/dist/runtime/server/utils/require-admin.js

@@ -2,7 +2,6 @@ import { createError } from "h3";
 import { getUserSession, useRuntimeConfig } from "#imports";
 import { assertSameOrigin } from "./same-origin.js";
 import { findUserById, passwordStamp } from "./users.js";
-export { assertSameOrigin };
 export function isSuperAdminEmail(event, email) {
   const { adminEmail } = useRuntimeConfig(event).cms;
   return !!adminEmail && email.toLowerCase() === adminEmail.toLowerCase();

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>[];

package/dist/runtime/server/utils/write-statements.js

@@ -0,0 +1,75 @@
+import { eq, getTableColumns, inArray } from "drizzle-orm";
+import { isMediaFolderMarker, mediaFolderDepth, mediaFolderMarkerKey } from "../../shared/index.js";
+import { nowTimestamp } from "../../shared/timestamps.js";
+export const KEY_CHUNK = 90;
+const JOIN_INSERT_CHUNK = 30;
+export 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 joinWriteStatements(db, join, sourceId, ids) {
+  const statements = [
+    db.delete(join.table).where(eq(join.sourceId, sourceId))
+  ];
+  const rows = ids.map((targetId, position) => ({ sourceId, targetId, position }));
+  for (const chunk of chunks(rows, JOIN_INSERT_CHUNK)) {
+    statements.push(db.insert(join.table).values(chunk));
+  }
+  return statements;
+}
+export function mediaFolderMarkerValues(folder) {
+  return {
+    key: mediaFolderMarkerKey(folder),
+    mime: "application/x-empty",
+    size: 0,
+    width: null,
+    height: null,
+    alt: null,
+    folder
+  };
+}
+export function planMediaFolderRename(rows) {
+  const folders = /* @__PURE__ */ new Map();
+  const markers = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (!isMediaFolderMarker(row.key)) {
+      if (row.folder) folders.set(row.folder, row.target);
+    } else if (row.target) {
+      markers.add(row.target);
+    }
+  }
+  const markerKeys = new Set([...markers].map(mediaFolderMarkerKey));
+  return {
+    folders: [...folders].sort(([a], [b]) => mediaFolderDepth(a) - mediaFolderDepth(b)),
+    markers: [...markers],
+    staleMarkers: rows.filter((row) => isMediaFolderMarker(row.key) && !markerKeys.has(row.key)).map((row) => row.key)
+  };
+}
+function mediaColumns(table) {
+  const columns = getTableColumns(table);
+  return { key: columns.key, folder: columns.folder };
+}
+export function mediaFolderRenameStatements(db, table, plan) {
+  const columns = mediaColumns(table);
+  const statements = [];
+  for (const [folder, target] of plan.folders) {
+    statements.push(db.update(table).set({ folder: target }).where(eq(columns.folder, folder)));
+  }
+  for (const folder of plan.markers) {
+    const values = mediaFolderMarkerValues(folder);
+    statements.push(
+      db.insert(table).values({ ...values, createdAt: nowTimestamp() }).onConflictDoUpdate({ target: columns.key, set: values })
+    );
+  }
+  for (const keys of chunks(plan.staleMarkers, KEY_CHUNK)) {
+    statements.push(db.delete(table).where(inArray(columns.key, keys)));
+  }
+  return statements;
+}
+export function mediaDeleteStatements(db, table, keys) {
+  const { key } = mediaColumns(table);
+  return chunks(keys, KEY_CHUNK).map((chunk) => db.delete(table).where(inArray(key, chunk)));
+}

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

@@ -60,6 +60,20 @@ export interface MediaUsage {
     title: string | null;
     field: string;
 }
+export interface MediaUsageEntry {
+    collection: string;
+    label: string;
+    kind: CmsEntryKind;
+    id: string | null;
+    title: string | null;
+    fields: string[];
+}
+export declare function groupMediaUsage(usage: MediaUsage[]): MediaUsageEntry[];
+export interface MediaUsageGroup {
+    key: string;
+    entries: MediaUsageEntry[];
+}
+export declare function mediaUsageGroups(usage: Record<string, MediaUsage[]>, keys: string[]): MediaUsageGroup[];
 export interface BlockConfig {
     label: string;
     fields: Record<string, FieldConfig>;

package/dist/runtime/shared/index.js

@@ -110,6 +110,19 @@ export function expandMediaFolders(folders) {
   }
   return [...expanded].sort();
 }
+export function groupMediaUsage(usage) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const { field, ...rest } of usage) {
+    const id = `${rest.collection}\0${rest.id ?? ""}`;
+    const entry = entries.get(id);
+    if (!entry) entries.set(id, { ...rest, fields: [field] });
+    else if (!entry.fields.includes(field)) entry.fields.push(field);
+  }
+  return [...entries.values()];
+}
+export function mediaUsageGroups(usage, keys) {
+  return [...new Set(keys)].map((key) => ({ key, entries: groupMediaUsage(usage[key] ?? []) })).filter((group) => group.entries.length > 0);
+}
 export function isPrivateField(field) {
   return !!field.private;
 }

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

@@ -26,7 +26,6 @@ export interface CmsEntrySettings {
 }
 export type CmsSettingsMap = Record<string, CmsEntrySettings>;
 export declare function layoutFromConfig(input: CmsLayoutBlock[] | undefined): CmsFormLayout;
-export declare function layoutKeys(input: CmsLayoutBlock[] | undefined): string[];
 export declare function resolveFormLayout(fields: Record<string, FieldConfig>, layout: CmsFormLayout | undefined): CmsFormLayout;
 export declare function defaultListColumns(fields: Record<string, FieldConfig>, list: CmsListInput | undefined, extra?: string[]): string[];
 export declare function resolveListColumns(fields: Record<string, FieldConfig>, saved: string[] | undefined, list: CmsListInput | undefined, extra?: string[]): string[];

package/dist/runtime/shared/layout.js

@@ -30,9 +30,6 @@ function sectionsFromBlocks(blocks) {
 export function layoutFromConfig(input) {
   return { main: sectionsFromBlocks(input) };
 }
-export function layoutKeys(input) {
-  return layoutFromConfig(input).main.flatMap((section) => section.rows.flat());
-}
 function cloneSection(section) {
   return { ...section, rows: section.rows.map((row) => [...row]) };
 }

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

@@ -0,0 +1,4 @@
+export declare const SQLITE_ISO_FORMAT = "%Y-%m-%dT%H:%M:%fZ";
+export declare function nowTimestamp(): string;
+export declare function normalizeTimestamp<T>(value: T): T | string;
+export declare function normalizeTimestampFields<T extends Record<string, unknown>>(row: T, keys?: readonly string[]): T;

package/dist/runtime/shared/timestamps.js

@@ -0,0 +1,24 @@
+export const SQLITE_ISO_FORMAT = "%Y-%m-%dT%H:%M:%fZ";
+export function nowTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+const TIMESTAMP_PATTERN = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})(?:\.(\d+))?(Z|[+-]\d{2}(?::?\d{2})?)?$/;
+export function normalizeTimestamp(value) {
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? value : value.toISOString();
+  if (typeof value !== "string") return value;
+  const match = TIMESTAMP_PATTERN.exec(value.trim());
+  if (!match) return value;
+  const [, date, time, fraction = "", zone] = match;
+  const millis = fraction.padEnd(3, "0").slice(0, 3);
+  const utc = `${date}T${time}.${millis}Z`;
+  if (!zone || zone === "Z") return utc;
+  const offset = zone.length === 3 ? `${zone}:00` : zone.includes(":") ? zone : `${zone.slice(0, 3)}:${zone.slice(3)}`;
+  const parsed = /* @__PURE__ */ new Date(`${date}T${time}.${millis}${offset}`);
+  return Number.isNaN(parsed.getTime()) ? value : parsed.toISOString();
+}
+export function normalizeTimestampFields(row, keys = ["createdAt", "updatedAt"]) {
+  for (const key of keys) {
+    if (Object.hasOwn(row, key)) row[key] = normalizeTimestamp(row[key]);
+  }
+  return row;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xleddyl/nuxt-cms",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Lightweight CMS that ships with your Nuxt app: runs on the Nitro server, content types defined in code, /cms admin panel, GraphQL API, SQLite or Postgres. No external CMS needed!",
   "license": "MIT",
   "author": "Edoardo Alberti (https://github.com/xleddyl)",