@xleddyl/nuxt-cms 0.1.9

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

@@ -0,0 +1,72 @@
+import { GraphQLError, Kind } from "graphql";
+const DEFAULT_MAX_DEPTH = 8;
+const DEFAULT_MAX_FIELDS = 500;
+function measure(selectionSet, fragments, visited) {
+  let max = 0;
+  for (const selection of selectionSet.selections) {
+    if (selection.kind === Kind.FIELD) {
+      if (selection.name.value.startsWith("__")) continue;
+      const depth = selection.selectionSet ? 1 + measure(selection.selectionSet, fragments, visited) : 1;
+      max = Math.max(max, depth);
+    } else if (selection.kind === Kind.FRAGMENT_SPREAD) {
+      const name = selection.name.value;
+      if (visited.has(name)) continue;
+      const fragment = fragments.get(name);
+      if (fragment) {
+        visited.add(name);
+        max = Math.max(max, measure(fragment.selectionSet, fragments, visited));
+        visited.delete(name);
+      }
+    } else if (selection.kind === Kind.INLINE_FRAGMENT) {
+      max = Math.max(max, measure(selection.selectionSet, fragments, visited));
+    }
+  }
+  return max;
+}
+export function createDepthRule(maxDepth) {
+  const limit = typeof maxDepth === "number" && Number.isFinite(maxDepth) && maxDepth > 0 ? maxDepth : DEFAULT_MAX_DEPTH;
+  return (context) => ({
+    OperationDefinition(node) {
+      const fragments = /* @__PURE__ */ new Map();
+      for (const definition of context.getDocument().definitions) {
+        if (definition.kind === Kind.FRAGMENT_DEFINITION)
+          fragments.set(definition.name.value, definition);
+      }
+      const depth = measure(node.selectionSet, fragments, /* @__PURE__ */ new Set());
+      if (depth > limit) {
+        context.reportError(
+          new GraphQLError(`Query is too deep: depth ${depth} exceeds the maximum of ${limit}`)
+        );
+      }
+    }
+  });
+}
+export function createBreadthRule(maxFields) {
+  const limit = typeof maxFields === "number" && Number.isFinite(maxFields) && maxFields > 0 ? maxFields : DEFAULT_MAX_FIELDS;
+  return (context) => {
+    let count = 0;
+    let reported = false;
+    return {
+      Field() {
+        count++;
+        if (count > limit && !reported) {
+          reported = true;
+          context.reportError(
+            new GraphQLError(
+              `Query has too many field selections: exceeds the maximum of ${limit}`
+            )
+          );
+        }
+      }
+    };
+  };
+}
+export function createIntrospectionRule() {
+  return (context) => ({
+    Field(node) {
+      if (node.name.value === "__schema" || node.name.value === "__type") {
+        context.reportError(new GraphQLError("Introspection is disabled"));
+      }
+    }
+  });
+}

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

@@ -0,0 +1,14 @@
+interface Ctx {
+    loaders: Map<string, BatchLoader<unknown, unknown>>;
+}
+declare class BatchLoader<K, V> {
+    private batchFn;
+    private queue;
+    private scheduled;
+    constructor(batchFn: (keys: K[]) => Promise<Map<K, V>>);
+    load(key: K): Promise<V | undefined>;
+    private flush;
+}
+export declare function buildCmsSchema(): import("graphql-yoga").GraphQLSchemaWithContext<Ctx & import("graphql-yoga").YogaInitialContext>;
+export declare function createGraphqlContext(): Ctx;
+export {};

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

@@ -0,0 +1,317 @@
+import {
+  and,
+  asc,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  isNotNull,
+  isNull,
+  like,
+  lt,
+  lte,
+  ne,
+  sql
+} from "drizzle-orm";
+import { GraphQLError, GraphQLScalarType, valueFromASTUntyped } from "graphql";
+import { createSchema } from "graphql-yoga";
+import cmsConfig from "#cms-config";
+import { useDb } from "#cms-db";
+import * as cmsTables from "#cms-tables";
+import { useRuntimeConfig } from "#imports";
+import { mediaPublicUrl, mediaTypeFor, translatableFieldKeys } from "../../shared/index.js";
+import { blockTypeName, blockUnionName, renderGraphqlSdl, typeName } from "../../shared/graphql-sdl.js";
+import { getContentI18n, resolveTable, tableColumns } from "./registry.js";
+const MAX_LIMIT = 100;
+const DEFAULT_LIMIT = 50;
+const LOCALE = Symbol("locale");
+class BatchLoader {
+  constructor(batchFn) {
+    this.batchFn = batchFn;
+  }
+  queue = [];
+  scheduled = false;
+  load(key) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ key, resolve, reject });
+      if (!this.scheduled) {
+        this.scheduled = true;
+        queueMicrotask(() => void this.flush());
+      }
+    });
+  }
+  async flush() {
+    const batch = this.queue;
+    this.queue = [];
+    this.scheduled = false;
+    try {
+      const map = await this.batchFn([...new Set(batch.map((b) => b.key))]);
+      for (const { key, resolve } of batch) resolve(map.get(key));
+    } catch (error) {
+      for (const { reject } of batch) reject(error);
+    }
+  }
+}
+function getLoader(ctx, cacheKey, batchFn) {
+  let loader = ctx.loaders.get(cacheKey);
+  if (!loader) {
+    loader = new BatchLoader(batchFn);
+    ctx.loaders.set(cacheKey, loader);
+  }
+  return loader;
+}
+function tableFor(name) {
+  const table = resolveTable(name);
+  if (!table) throw new GraphQLError(`No table for collection: ${name}`);
+  return table;
+}
+function publishedFilter(entry, table) {
+  if (!entry.drafts) return [];
+  const status = tableColumns(table).status;
+  return status ? [eq(status, "published")] : [];
+}
+function localeOf(parent) {
+  return parent[LOCALE] ?? getContentI18n().defaultLocale;
+}
+function resolveLocaleArg(locale) {
+  const { locales, defaultLocale } = getContentI18n();
+  if (locale == null || locale === "") return defaultLocale;
+  if (!locales.includes(String(locale))) {
+    throw new GraphQLError(
+      `Unknown locale: ${locale}${locales.length ? ` (available: ${locales.join(", ")})` : ""}`
+    );
+  }
+  return String(locale);
+}
+function localizeRow(entry, row, locale) {
+  const { defaultLocale } = getContentI18n();
+  const result = { ...row, [LOCALE]: locale };
+  for (const key of translatableFieldKeys(entry)) {
+    const value = row[key];
+    result[key] = value?.[locale] ?? value?.[defaultLocale] ?? null;
+  }
+  return result;
+}
+const OPERATORS = {
+  eq: (column, value) => eq(column, value),
+  neq: (column, value) => ne(column, value),
+  gt: (column, value) => gt(column, value),
+  gte: (column, value) => gte(column, value),
+  lt: (column, value) => lt(column, value),
+  lte: (column, value) => lte(column, value),
+  like: (column, value) => like(column, String(value).replaceAll("*", "%")),
+  in: (column, value) => inArray(column, value)
+};
+function filterConditions(table, filters) {
+  if (!filters) return [];
+  const conditions = [];
+  for (const [key, ops] of Object.entries(filters)) {
+    if (!ops) continue;
+    const column = tableColumns(table)[key];
+    if (!column) throw new GraphQLError(`Unknown filter field: ${key}`);
+    for (const [op, value] of Object.entries(ops)) {
+      if (value === void 0) continue;
+      if (op === "isNull") {
+        conditions.push(value ? isNull(column) : isNotNull(column));
+        continue;
+      }
+      if (value === null) continue;
+      if (op === "in" && !value.length) {
+        throw new GraphQLError(`Empty in list for ${key}`);
+      }
+      const operator = OPERATORS[op];
+      if (!operator) throw new GraphQLError(`Unknown operator for ${key}: ${op}`);
+      conditions.push(operator(column, value));
+    }
+  }
+  return conditions;
+}
+function sortOrder(table, sort) {
+  const order = [];
+  for (const part of sort ?? []) {
+    const column = tableColumns(table)[part.field];
+    if (!column) throw new GraphQLError(`Unknown sort field: ${part.field}`);
+    order.push(part.direction === "desc" ? desc(column) : asc(column));
+  }
+  if (!order.length) {
+    const fallback = tableColumns(table).createdAt ?? tableColumns(table).id;
+    if (fallback) order.push(desc(fallback));
+  }
+  return order;
+}
+let mediaBase;
+function getMediaBase() {
+  mediaBase ??= useRuntimeConfig().public.cms.mediaBaseUrl;
+  return mediaBase;
+}
+async function resolveMedia(ctx, key) {
+  if (!key) return null;
+  const row = await loadMedia(ctx).load(key);
+  return row ? mediaObject(key, row) : null;
+}
+function loadById(ctx, targetName) {
+  return getLoader(ctx, `byId:${targetName}`, async (ids) => {
+    const config = cmsConfig;
+    const entry = config[targetName];
+    const table = tableFor(targetName);
+    const id = tableColumns(table).id;
+    const rows = await useDb().select().from(table).where(and(inArray(id, ids), ...publishedFilter(entry, table)));
+    return new Map(
+      rows.map((row) => [
+        row.id,
+        row
+      ])
+    );
+  });
+}
+function loadManyToMany(ctx, name, key, field) {
+  return getLoader(
+    ctx,
+    `m2m:${name}:${key}`,
+    async (sourceIds) => {
+      const config = cmsConfig;
+      const targetEntry = config[field.to];
+      const join = cmsTables[`${name}_${key}`];
+      const target = tableFor(field.to);
+      const joinCols = tableColumns(join);
+      const rows = await useDb().select({ sourceId: joinCols.sourceId, target }).from(join).innerJoin(target, eq(joinCols.targetId, tableColumns(target).id)).where(
+        and(inArray(joinCols.sourceId, sourceIds), ...publishedFilter(targetEntry, target))
+      ).orderBy(asc(joinCols.position));
+      const map = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        if (!map.has(row.sourceId)) map.set(row.sourceId, []);
+        map.get(row.sourceId).push(row.target);
+      }
+      for (const id of sourceIds) {
+        if (!map.has(id)) map.set(id, []);
+      }
+      return map;
+    }
+  );
+}
+function loadMedia(ctx) {
+  return getLoader(ctx, "media", async (keys) => {
+    const media = cmsTables.cms_media;
+    const keyCol = tableColumns(media).key;
+    const rows = await useDb().select().from(media).where(inArray(keyCol, keys));
+    return new Map(
+      rows.map((row) => [
+        row.key,
+        row
+      ])
+    );
+  });
+}
+function mediaObject(key, row) {
+  return {
+    key,
+    url: mediaPublicUrl(getMediaBase(), key),
+    alt: row?.alt ?? null,
+    folder: row?.folder ?? null,
+    mime: row?.mime ?? null,
+    size: row?.size ?? null,
+    width: row?.width ?? null,
+    height: row?.height ?? null,
+    type: mediaTypeFor(row?.mime, key)
+  };
+}
+function entryResolvers(config, name, entry) {
+  const resolvers = {};
+  for (const [key, field] of Object.entries(entry.fields)) {
+    if (field.type === "relation" && field.cardinality === "many-to-many") {
+      resolvers[key] = async (parent, _args, ctx) => {
+        const rows = await loadManyToMany(ctx, name, key, field).load(parent.id);
+        return (rows ?? []).map((row) => localizeRow(config[field.to], row, localeOf(parent)));
+      };
+    } else if (field.type === "relation") {
+      resolvers[key] = async (parent, _args, ctx) => {
+        const id = parent[key];
+        if (id == null) return null;
+        const row = await loadById(ctx, field.to).load(id);
+        return row ? localizeRow(config[field.to], row, localeOf(parent)) : null;
+      };
+    } else if (field.type === "media") {
+      resolvers[key] = (parent, _args, ctx) => resolveMedia(ctx, parent[key]);
+    }
+  }
+  return resolvers;
+}
+function blockResolvers(name, key, field) {
+  const resolvers = {};
+  resolvers[blockUnionName(name, key)] = {
+    __resolveType: (value) => blockTypeName(name, key, String(value.type))
+  };
+  for (const [blockName, block] of Object.entries(field.blocks ?? {})) {
+    const mediaFields = Object.entries(block.fields).filter(([, f]) => f.type === "media");
+    if (!mediaFields.length) continue;
+    const fieldLevel = {};
+    for (const [blockFieldKey] of mediaFields) {
+      fieldLevel[blockFieldKey] = (parent, _args, ctx) => resolveMedia(ctx, parent[blockFieldKey]);
+    }
+    resolvers[blockTypeName(name, key, blockName)] = fieldLevel;
+  }
+  return resolvers;
+}
+export function buildCmsSchema() {
+  const config = cmsConfig;
+  const entries = Object.entries(config);
+  const queryResolvers = {};
+  const typeResolvers = {};
+  for (const [name, entry] of entries) {
+    const gqlType = typeName(name);
+    const fieldLevel = entryResolvers(config, name, entry);
+    if (Object.keys(fieldLevel).length) typeResolvers[gqlType] = fieldLevel;
+    for (const [key, field] of Object.entries(entry.fields)) {
+      if (field.type === "blocks") Object.assign(typeResolvers, blockResolvers(name, key, field));
+    }
+    if (entry.kind === "single") {
+      queryResolvers[name] = async (_, args) => {
+        const locale = resolveLocaleArg(args.locale);
+        const table = tableFor(name);
+        const published = publishedFilter(entry, table);
+        const [row] = await useDb().select().from(table).where(published.length ? and(...published) : void 0).limit(1);
+        return row ? localizeRow(entry, row, locale) : null;
+      };
+      continue;
+    }
+    queryResolvers[name] = async (_, args) => {
+      const locale = resolveLocaleArg(args.locale);
+      const table = tableFor(name);
+      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);
+      return rows.map((row) => localizeRow(entry, row, locale));
+    };
+    queryResolvers[`${name}ById`] = async (_, args) => {
+      const locale = resolveLocaleArg(args.locale);
+      const table = tableFor(name);
+      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;
+    };
+    queryResolvers[`${name}Count`] = async (_, args) => {
+      const table = tableFor(name);
+      const where = [...publishedFilter(entry, table), ...filterConditions(table, args.filters)];
+      const [counted] = await useDb().select({ total: sql`count(*)` }).from(table).where(where.length ? and(...where) : void 0);
+      return counted?.total ?? 0;
+    };
+  }
+  const jsonScalar = new GraphQLScalarType({
+    name: "JSON",
+    serialize: (value) => value,
+    parseValue: (value) => value,
+    parseLiteral: (ast) => valueFromASTUntyped(ast)
+  });
+  return createSchema({
+    typeDefs: renderGraphqlSdl(config),
+    resolvers: {
+      JSON: jsonScalar,
+      Query: queryResolvers,
+      ...typeResolvers
+    }
+  });
+}
+export function createGraphqlContext() {
+  return { loaders: /* @__PURE__ */ new Map() };
+}

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

@@ -0,0 +1,24 @@
+import type { H3Event } from 'h3';
+import { AwsClient } from 'aws4fetch';
+import type { MediaItem } from '../../shared/index.js';
+interface MediaConfig {
+    endpoint: string;
+    region: string;
+    bucket: string;
+    presignExpiry: number;
+    accessKeyId: string;
+    secretAccessKey: string;
+}
+export declare function encodeKey(key: string): string;
+export declare function useMediaConfig(event: H3Event): {
+    media: MediaConfig;
+    publicUrl: (key: string) => string | null;
+};
+export declare function useMediaStorage(event: H3Event): {
+    media: MediaConfig;
+    client: AwsClient;
+    bucketUrl: string;
+    publicUrl: (key: string) => string | null;
+};
+export declare function toMediaItem(row: Omit<MediaItem, 'type' | 'url'>, publicUrl: (key: string) => string | null): MediaItem;
+export {};

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

@@ -0,0 +1,38 @@
+import { AwsClient } from "aws4fetch";
+import { createError } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { mediaPublicUrl, mediaTypeFor } from "../../shared/index.js";
+export function encodeKey(key) {
+  return key.split("/").map(encodeURIComponent).join("/");
+}
+export function useMediaConfig(event) {
+  const config = useRuntimeConfig(event);
+  const media = config.cms.media;
+  if (!media.endpoint || !media.bucket || !media.accessKeyId || !media.secretAccessKey) {
+    throw createError({
+      statusCode: 501,
+      statusMessage: "Media storage is not configured (cms.media in nuxt.config)"
+    });
+  }
+  const { mediaBaseUrl } = config.public.cms;
+  const publicUrl = (key) => mediaPublicUrl(mediaBaseUrl, key);
+  return { media, publicUrl };
+}
+export function useMediaStorage(event) {
+  const { media, publicUrl } = useMediaConfig(event);
+  const client = new AwsClient({
+    accessKeyId: media.accessKeyId,
+    secretAccessKey: media.secretAccessKey,
+    region: media.region,
+    service: "s3"
+  });
+  const bucketUrl = `${media.endpoint.replace(/\/+$/, "")}/${media.bucket}`;
+  return { media, client, bucketUrl, publicUrl };
+}
+export function toMediaItem(row, publicUrl) {
+  return {
+    ...row,
+    type: mediaTypeFor(row.mime, row.key),
+    url: publicUrl(row.key)
+  };
+}

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

@@ -0,0 +1,20 @@
+import type { AnySQLiteColumn, SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { H3Event } from 'h3';
+import { z } from 'zod';
+import type { CmsEntry, CmsI18n } from '../../shared/index.js';
+export declare function getContentI18n(): CmsI18n;
+export declare function resolveTable(name: string): SQLiteTable | undefined;
+export declare function tableColumns(table: SQLiteTable): Record<string, AnySQLiteColumn>;
+export declare function idColumn(table: SQLiteTable): AnySQLiteColumn;
+export declare function withUpdatedAt(table: SQLiteTable, values: Record<string, unknown>): {
+    [x: string]: unknown;
+};
+export declare function getRegistryEntry(event: H3Event): {
+    name: string;
+    entry: CmsEntry;
+    table: SQLiteTable;
+};
+export declare function buildValidator(entry: CmsEntry): z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>;
+export declare function parseId(event: H3Event): string;

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

@@ -0,0 +1,47 @@
+import { createError, getRouterParam } from "h3";
+import { z } from "zod";
+import cmsConfig from "#cms-config";
+import * as cmsTables from "#cms-tables";
+import { useRuntimeConfig } from "#imports";
+import { buildEntrySchema } from "../../shared/validation.js";
+let contentI18n;
+export function getContentI18n() {
+  if (!contentI18n) {
+    const { i18n } = useRuntimeConfig().public.cms ?? {};
+    contentI18n = { locales: i18n?.locales ?? [], defaultLocale: i18n?.defaultLocale ?? "en" };
+  }
+  return contentI18n;
+}
+export function resolveTable(name) {
+  const entry = cmsConfig[name];
+  return entry?.table ?? cmsTables[name];
+}
+export function tableColumns(table) {
+  return table;
+}
+export function idColumn(table) {
+  return tableColumns(table).id;
+}
+export function withUpdatedAt(table, values) {
+  const set = { ...values };
+  if ("updatedAt" in table) set.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return set;
+}
+export function getRegistryEntry(event) {
+  const name = getRouterParam(event, "collection");
+  const config = cmsConfig;
+  if (!name || !Object.hasOwn(config, name)) {
+    throw createError({ statusCode: 404, statusMessage: `Unknown collection: ${name}` });
+  }
+  const table = resolveTable(name);
+  if (!table) {
+    throw createError({ statusCode: 500, statusMessage: `No table for collection: ${name}` });
+  }
+  return { name, entry: config[name], table };
+}
+export function buildValidator(entry) {
+  return buildEntrySchema(entry, getContentI18n());
+}
+export function parseId(event) {
+  return z.string().min(1).parse(getRouterParam(event, "id"));
+}

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

@@ -0,0 +1,12 @@
+import type { CmsEntry } from '../../shared/index.js';
+type Row = Record<string, unknown>;
+export declare function splitRelationValues(entry: CmsEntry, body: Row): {
+    values: {
+        [k: string]: unknown;
+    };
+    lists: Record<string, string[]>;
+};
+export declare function assertRelationTargets(entry: CmsEntry, lists: Record<string, string[]>): Promise<void>;
+export declare function saveManyToMany(name: string, sourceId: string, lists: Record<string, string[]>): Promise<void>;
+export declare function attachManyToMany<T extends Row>(name: string, entry: CmsEntry, rows: T[]): Promise<T[]>;
+export {};

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

@@ -0,0 +1,80 @@
+import { asc, eq, inArray } from "drizzle-orm";
+import { createError } from "h3";
+import { useDb } from "#cms-db";
+import * as cmsTables from "#cms-tables";
+import { resolveTable, tableColumns } from "./registry.js";
+function manyToManyKeys(entry) {
+  return Object.entries(entry.fields).filter(([, field]) => field.type === "relation" && field.cardinality === "many-to-many").map(([key]) => key);
+}
+function joinTable(name, key) {
+  const table = cmsTables[`${name}_${key}`];
+  if (!table) {
+    throw createError({ statusCode: 500, statusMessage: `No join table for ${name}.${key}` });
+  }
+  const columns = table;
+  return {
+    table,
+    sourceId: columns.sourceId,
+    targetId: columns.targetId,
+    position: columns.position
+  };
+}
+export function splitRelationValues(entry, body) {
+  const keys = manyToManyKeys(entry);
+  const values = Object.fromEntries(Object.entries(body).filter(([key]) => !keys.includes(key)));
+  const lists = {};
+  for (const key of keys) {
+    const ids = body[key] ?? [];
+    lists[key] = [...new Set(ids)];
+  }
+  return { values, lists };
+}
+export async function assertRelationTargets(entry, lists) {
+  const db = useDb();
+  for (const [key, ids] of Object.entries(lists)) {
+    if (!ids.length) continue;
+    const field = entry.fields[key];
+    const target = resolveTable(field.to);
+    if (!target) continue;
+    const idCol = tableColumns(target).id;
+    const rows = await db.select({ id: idCol }).from(target).where(inArray(idCol, ids));
+    if (rows.length !== ids.length) {
+      const found = new Set(rows.map((row) => row.id));
+      const missing = ids.filter((id) => !found.has(id));
+      throw createError({
+        statusCode: 422,
+        statusMessage: `Unknown ${field.to} id(s) for '${key}': ${missing.join(", ")}`
+      });
+    }
+  }
+}
+export async function saveManyToMany(name, sourceId, lists) {
+  const db = useDb();
+  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 async function attachManyToMany(name, entry, rows) {
+  const keys = manyToManyKeys(entry);
+  const ids = rows.map((row) => row.id).filter((id) => id != null);
+  if (!keys.length || !ids.length) return rows;
+  const db = useDb();
+  for (const key of keys) {
+    const join = joinTable(name, key);
+    const links = await db.select().from(join.table).where(inArray(join.sourceId, ids)).orderBy(asc(join.position));
+    const grouped = /* @__PURE__ */ new Map();
+    for (const link of links) {
+      const list = grouped.get(link.sourceId) ?? [];
+      list.push(link.targetId);
+      grouped.set(link.sourceId, list);
+    }
+    for (const row of rows) {
+      row[key] = grouped.get(row.id) ?? [];
+    }
+  }
+  return rows;
+}

package/dist/runtime/server/utils/require-admin.d.ts

@@ -0,0 +1,2 @@
+import type { H3Event } from 'h3';
+export declare function requireAdmin(event: H3Event): Promise<void>;

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

@@ -0,0 +1,13 @@
+import { createError } from "h3";
+import { getUserSession, useRuntimeConfig } from "#imports";
+export async function requireAdmin(event) {
+  const session = await getUserSession(event);
+  const email = session.user?.email;
+  if (!email) {
+    throw createError({ statusCode: 401, statusMessage: "Authentication required" });
+  }
+  const { adminEmail } = useRuntimeConfig(event).cms;
+  if (!adminEmail || email.toLowerCase() !== adminEmail.toLowerCase()) {
+    throw createError({ statusCode: 403, statusMessage: "Not authorized" });
+  }
+}

package/dist/runtime/shared/empty-config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/runtime/shared/empty-config.js

@@ -0,0 +1 @@
+export default {};

package/dist/runtime/shared/graphql-sdl.d.ts

@@ -0,0 +1,5 @@
+import type { CmsConfig } from './index.js';
+export declare function typeName(name: string): string;
+export declare function blockUnionName(entryName: string, fieldKey: string): string;
+export declare function blockTypeName(entryName: string, fieldKey: string, blockName: string): string;
+export declare function renderGraphqlSdl(config: CmsConfig): string;