@xleddyl/nuxt-cms 0.1.9

package/dist/runtime/server/api/collection.get.js

@@ -0,0 +1,19 @@
+import { desc } from "drizzle-orm";
+import { defineEventHandler } from "h3";
+import { useDb } from "#cms-db";
+import { getRegistryEntry, idColumn, tableColumns } from "../utils/registry.js";
+import { attachManyToMany } from "../utils/relations.js";
+import { requireAdmin } from "../utils/require-admin.js";
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { name, entry, table } = getRegistryEntry(event);
+  const db = useDb();
+  if (entry.kind === "single") {
+    const rows2 = await db.select().from(table).limit(1);
+    await attachManyToMany(name, entry, rows2);
+    return rows2[0] ?? null;
+  }
+  const orderBy = tableColumns(table).createdAt ?? idColumn(table);
+  const rows = await db.select().from(table).orderBy(desc(orderBy));
+  return attachManyToMany(name, entry, rows);
+});

package/dist/runtime/server/api/collection.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Record<string, unknown> | undefined>>;
+export default _default;

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

@@ -0,0 +1,30 @@
+import { createError, defineEventHandler, readValidatedBody } from "h3";
+import { useDb } from "#cms-db";
+import { customId } from "../utils/custom-id.js";
+import { mapConstraintErrors } from "../utils/db-errors.js";
+import { buildValidator, getRegistryEntry } from "../utils/registry.js";
+import {
+  assertRelationTargets,
+  attachManyToMany,
+  saveManyToMany,
+  splitRelationValues
+} from "../utils/relations.js";
+import { requireAdmin } from "../utils/require-admin.js";
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { name, entry, table } = getRegistryEntry(event);
+  if (entry.kind !== "collection") {
+    throw createError({ statusCode: 405, statusMessage: "Single objects are updated with PUT" });
+  }
+  const body = await readValidatedBody(event, buildValidator(entry).parse);
+  const { values, lists } = splitRelationValues(entry, body);
+  await assertRelationTargets(entry, lists);
+  if (entry.drafts) values.status ??= "draft";
+  values.id = customId(entry.id);
+  return mapConstraintErrors(async () => {
+    const [row] = await useDb().insert(table).values(values).returning();
+    await saveManyToMany(name, row.id, lists);
+    const [attached] = await attachManyToMany(name, entry, [row]);
+    return attached;
+  });
+});

package/dist/runtime/server/api/collection.put.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Record<string, unknown> | undefined>>;
+export default _default;

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

@@ -0,0 +1,28 @@
+import { createError, defineEventHandler, readValidatedBody } from "h3";
+import { useDb } from "#cms-db";
+import { mapConstraintErrors } from "../utils/db-errors.js";
+import { buildValidator, getRegistryEntry, idColumn, withUpdatedAt } from "../utils/registry.js";
+import {
+  assertRelationTargets,
+  attachManyToMany,
+  saveManyToMany,
+  splitRelationValues
+} from "../utils/relations.js";
+import { requireAdmin } from "../utils/require-admin.js";
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { name, entry, table } = getRegistryEntry(event);
+  if (entry.kind !== "single") {
+    throw createError({ statusCode: 405, statusMessage: "Collections are updated with PUT /:id" });
+  }
+  const body = await readValidatedBody(event, buildValidator(entry).parse);
+  const { values, lists } = splitRelationValues(entry, body);
+  await assertRelationTargets(entry, lists);
+  const set = withUpdatedAt(table, values);
+  return mapConstraintErrors(async () => {
+    const [row] = await useDb().insert(table).values({ id: entry.id, ...set }).onConflictDoUpdate({ target: idColumn(table), set }).returning();
+    await saveManyToMany(name, entry.id, lists);
+    const [attached] = await attachManyToMany(name, entry, [row]);
+    return attached;
+  });
+});

package/dist/runtime/server/api/item.delete.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    deleted: boolean;
+}>>;
+export default _default;

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

@@ -0,0 +1,19 @@
+import { eq } from "drizzle-orm";
+import { createError, defineEventHandler } from "h3";
+import { useDb } from "#cms-db";
+import { mapConstraintErrors } from "../utils/db-errors.js";
+import { getRegistryEntry, idColumn, parseId } from "../utils/registry.js";
+import { requireAdmin } from "../utils/require-admin.js";
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { entry, table } = getRegistryEntry(event);
+  if (entry.kind !== "collection") {
+    throw createError({ statusCode: 405, statusMessage: "Single objects cannot be deleted" });
+  }
+  const id = parseId(event);
+  return mapConstraintErrors(async () => {
+    const [row] = await useDb().delete(table).where(eq(idColumn(table), id)).returning();
+    if (!row) throw createError({ statusCode: 404, statusMessage: "Row not found" });
+    return { deleted: true };
+  });
+});

package/dist/runtime/server/api/item.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Record<string, unknown> | undefined>>;
+export default _default;

package/dist/runtime/server/api/item.get.js

@@ -0,0 +1,18 @@
+import { eq } from "drizzle-orm";
+import { createError, defineEventHandler } from "h3";
+import { useDb } from "#cms-db";
+import { getRegistryEntry, idColumn, parseId } from "../utils/registry.js";
+import { attachManyToMany } from "../utils/relations.js";
+import { requireAdmin } from "../utils/require-admin.js";
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { name, entry, table } = getRegistryEntry(event);
+  if (entry.kind !== "collection") {
+    throw createError({ statusCode: 404, statusMessage: "Single objects have no items" });
+  }
+  const id = parseId(event);
+  const rows = await useDb().select().from(table).where(eq(idColumn(table), id)).limit(1);
+  if (!rows[0]) throw createError({ statusCode: 404, statusMessage: "Row not found" });
+  const [attached] = await attachManyToMany(name, entry, [rows[0]]);
+  return attached;
+});

package/dist/runtime/server/api/item.put.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Record<string, unknown> | undefined>>;
+export default _default;

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

@@ -0,0 +1,40 @@
+import { eq } from "drizzle-orm";
+import { createError, defineEventHandler, readValidatedBody } from "h3";
+import { useDb } from "#cms-db";
+import {
+  buildValidator,
+  getRegistryEntry,
+  idColumn,
+  parseId,
+  withUpdatedAt
+} from "../utils/registry.js";
+import {
+  assertRelationTargets,
+  attachManyToMany,
+  saveManyToMany,
+  splitRelationValues
+} from "../utils/relations.js";
+import { requireAdmin } from "../utils/require-admin.js";
+import { mapConstraintErrors } from "../utils/db-errors.js";
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { name, entry, table } = getRegistryEntry(event);
+  if (entry.kind !== "collection") {
+    throw createError({
+      statusCode: 405,
+      statusMessage: "Single objects are updated with PUT without id"
+    });
+  }
+  const id = parseId(event);
+  const body = await readValidatedBody(event, buildValidator(entry).parse);
+  const { values, lists } = splitRelationValues(entry, body);
+  await assertRelationTargets(entry, lists);
+  const set = withUpdatedAt(table, values);
+  return mapConstraintErrors(async () => {
+    const [row] = await useDb().update(table).set(set).where(eq(idColumn(table), id)).returning();
+    if (!row) throw createError({ statusCode: 404, statusMessage: "Row not found" });
+    await saveManyToMany(name, id, lists);
+    const [attached] = await attachManyToMany(name, entry, [row]);
+    return attached;
+  });
+});

package/dist/runtime/server/api/media-presign.post.d.ts

@@ -0,0 +1,11 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    key: string;
+    uploadUrl: string;
+    method: string;
+    headers: {
+        'content-type': string;
+    };
+    publicUrl: string | null;
+    expiresIn: number;
+}>>;
+export default _default;

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

@@ -0,0 +1,51 @@
+import { randomUUID } from "node:crypto";
+import { createError, defineEventHandler, readValidatedBody } from "h3";
+import { z } from "zod";
+import { slugify } from "../../shared/index.js";
+import { useMediaStorage } from "../utils/media.js";
+import { requireAdmin } from "../utils/require-admin.js";
+const MAX_BASE_LENGTH = 80;
+const MAX_EXT_LENGTH = 10;
+const MAX_FILE_SIZE = 10 * 1024 * 1024;
+const bodySchema = z.object({
+  filename: z.string().trim().min(1).max(255),
+  contentType: z.string().regex(/^[-\w.+]+\/[-\w.+]+$/, "Invalid content type"),
+  size: z.number().int().positive()
+});
+function slugifyFilename(filename) {
+  const dot = filename.lastIndexOf(".");
+  const base = slugify(dot > 0 ? filename.slice(0, dot) : filename).slice(0, MAX_BASE_LENGTH) || "file";
+  const ext = dot > 0 ? filename.slice(dot + 1).toLowerCase().replace(/[^a-z0-9]/g, "").slice(0, MAX_EXT_LENGTH) : "";
+  return ext ? `${base}.${ext}` : base;
+}
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { media, client, bucketUrl, publicUrl } = useMediaStorage(event);
+  const { filename, contentType, size } = await readValidatedBody(event, bodySchema.parse);
+  if (size > MAX_FILE_SIZE) {
+    throw createError({
+      statusCode: 413,
+      statusMessage: "File exceeds the maximum size of 10 MB"
+    });
+  }
+  const now = /* @__PURE__ */ new Date();
+  const prefix = `${now.getUTCFullYear()}/${String(now.getUTCMonth() + 1).padStart(2, "0")}`;
+  const key = `${prefix}/${randomUUID()}-${slugifyFilename(filename)}`;
+  const url = new URL(`${bucketUrl}/${key}`);
+  url.searchParams.set("X-Amz-Expires", String(media.presignExpiry));
+  const signed = await client.sign(
+    new Request(url, {
+      method: "PUT",
+      headers: { "content-type": contentType, "content-length": String(size) }
+    }),
+    { aws: { signQuery: true, allHeaders: true } }
+  );
+  return {
+    key,
+    uploadUrl: signed.url,
+    method: "PUT",
+    headers: { "content-type": contentType },
+    publicUrl: publicUrl(key),
+    expiresIn: media.presignExpiry
+  };
+});

package/dist/runtime/server/api/media.delete.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    ok: boolean;
+}>>;
+export default _default;

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

@@ -0,0 +1,25 @@
+import { eq } from "drizzle-orm";
+import { createError, defineEventHandler, getValidatedQuery } from "h3";
+import { z } from "zod";
+import { useDb } from "#cms-db";
+import { cms_media } from "#cms-tables";
+import { objectKeySchema } from "../../shared/validation.js";
+import { encodeKey, useMediaStorage } from "../utils/media.js";
+import { requireAdmin } from "../utils/require-admin.js";
+const querySchema = z.object({ key: objectKeySchema });
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { client, bucketUrl } = useMediaStorage(event);
+  const { key } = await getValidatedQuery(event, querySchema.parse);
+  const db = useDb();
+  const [row] = await db.select().from(cms_media).where(eq(cms_media.key, key)).limit(1);
+  if (!row) {
+    throw createError({ statusCode: 404, statusMessage: "Media not found" });
+  }
+  const res = await client.fetch(`${bucketUrl}/${encodeKey(key)}`, { method: "DELETE" });
+  if (!res.ok && res.status !== 404) {
+    throw createError({ statusCode: 502, statusMessage: `Bucket delete failed (${res.status})` });
+  }
+  await db.delete(cms_media).where(eq(cms_media.key, key));
+  return { ok: true };
+});

package/dist/runtime/server/api/media.get.d.ts

@@ -0,0 +1,5 @@
+import type { MediaItem } from '../../shared/index.js';
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    items: MediaItem[];
+}>>;
+export default _default;

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

@@ -0,0 +1,13 @@
+import { desc } from "drizzle-orm";
+import { defineEventHandler } from "h3";
+import { useDb } from "#cms-db";
+import { cms_media } from "#cms-tables";
+import { toMediaItem, useMediaConfig } from "../utils/media.js";
+import { requireAdmin } from "../utils/require-admin.js";
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { publicUrl } = useMediaConfig(event);
+  const rows = await useDb().select().from(cms_media).orderBy(desc(cms_media.createdAt), desc(cms_media.id));
+  const items = rows.map((row) => toMediaItem(row, publicUrl));
+  return { items };
+});

package/dist/runtime/server/api/media.post.d.ts

@@ -0,0 +1,3 @@
+import type { MediaItem } from '../../shared/index.js';
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<MediaItem>>;
+export default _default;

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

@@ -0,0 +1,32 @@
+import { defineEventHandler, readValidatedBody } from "h3";
+import { z } from "zod";
+import { useDb } from "#cms-db";
+import { cms_media } from "#cms-tables";
+import { objectKeySchema } from "../../shared/validation.js";
+import { toMediaItem, useMediaConfig } from "../utils/media.js";
+import { requireAdmin } from "../utils/require-admin.js";
+const bodySchema = z.object({
+  key: objectKeySchema,
+  mime: z.string().max(255).nullish(),
+  size: z.number().int().nonnegative().nullish(),
+  width: z.number().int().positive().nullish(),
+  height: z.number().int().positive().nullish(),
+  alt: z.string().max(1024).nullish(),
+  folder: z.string().max(255).nullish()
+});
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { publicUrl } = useMediaConfig(event);
+  const body = await readValidatedBody(event, bodySchema.parse);
+  const values = {
+    key: body.key,
+    mime: body.mime ?? null,
+    size: body.size ?? null,
+    width: body.width ?? null,
+    height: body.height ?? null,
+    alt: body.alt ?? null,
+    folder: body.folder ?? null
+  };
+  const [row] = await useDb().insert(cms_media).values(values).onConflictDoUpdate({ target: cms_media.key, set: values }).returning();
+  return toMediaItem(row, publicUrl);
+});

package/dist/runtime/server/api/media.put.d.ts

@@ -0,0 +1,3 @@
+import type { MediaItem } from '../../shared/index.js';
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<MediaItem>>;
+export default _default;

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

@@ -0,0 +1,28 @@
+import { eq } from "drizzle-orm";
+import { createError, defineEventHandler, readValidatedBody } from "h3";
+import { z } from "zod";
+import { useDb } from "#cms-db";
+import { cms_media } from "#cms-tables";
+import { toMediaItem, useMediaConfig } from "../utils/media.js";
+import { requireAdmin } from "../utils/require-admin.js";
+const bodySchema = z.object({
+  id: z.number().int().positive(),
+  alt: z.string().max(1024).nullish(),
+  folder: z.string().max(255).nullish()
+});
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { publicUrl } = useMediaConfig(event);
+  const body = await readValidatedBody(event, bodySchema.parse);
+  const updates = {};
+  if (body.alt !== void 0) updates.alt = body.alt;
+  if (body.folder !== void 0) updates.folder = body.folder;
+  if (Object.keys(updates).length === 0) {
+    throw createError({ statusCode: 400, statusMessage: "No fields to update" });
+  }
+  const [row] = await useDb().update(cms_media).set(updates).where(eq(cms_media.id, body.id)).returning();
+  if (!row) {
+    throw createError({ statusCode: 404, statusMessage: "Media not found" });
+  }
+  return toMediaItem(row, publicUrl);
+});

package/dist/runtime/server/plugins/migrate-postgres.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import { existsSync } from "node:fs";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+import { useRuntimeConfig } from "#imports";
+import { useDb } from "../utils/db-postgres.js";
+export default async () => {
+  const { migrationsDir } = useRuntimeConfig().cms;
+  if (!existsSync(migrationsDir)) return;
+  await migrate(useDb(), { migrationsFolder: migrationsDir });
+};

package/dist/runtime/server/plugins/migrate-sqlite.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

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

@@ -0,0 +1,9 @@
+import { existsSync } from "node:fs";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { useRuntimeConfig } from "#imports";
+import { useDb } from "../utils/db-sqlite.js";
+export default () => {
+  const { migrationsDir } = useRuntimeConfig().cms;
+  if (!existsSync(migrationsDir)) return;
+  migrate(useDb(), { migrationsFolder: migrationsDir });
+};

package/dist/runtime/server/plugins/session-check.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/dist/runtime/server/plugins/session-check.js

@@ -0,0 +1,9 @@
+import { useRuntimeConfig } from "#imports";
+export default () => {
+  const { session } = useRuntimeConfig();
+  if (!session?.password || session.password.length < 32) {
+    throw new Error(
+      "[nuxt-cms] Admin sessions require NUXT_SESSION_PASSWORD (min 32 characters) in production"
+    );
+  }
+};

package/dist/runtime/server/routes/auth/login.post.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    loggedIn: boolean;
+}>>;
+export default _default;

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

@@ -0,0 +1,62 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import { createError, defineEventHandler, getRequestIP, readValidatedBody } from "h3";
+import { z } from "zod";
+import { setUserSession, useRuntimeConfig } from "#imports";
+const credentialsSchema = z.object({
+  email: z.string().trim().min(1),
+  password: z.string().min(1)
+});
+const RATE_WINDOW_MS = 15 * 6e4;
+const RATE_MAX_FAILURES = 10;
+const RATE_GLOBAL_MAX_FAILURES = 100;
+const RATE_PRUNE_THRESHOLD = 1e3;
+const failures = /* @__PURE__ */ new Map();
+let globalFailures = { count: 0, resetAt: 0 };
+function pruneFailures(now) {
+  if (failures.size < RATE_PRUNE_THRESHOLD) return;
+  for (const [ip, entry] of failures) {
+    if (entry.resetAt <= now) failures.delete(ip);
+  }
+}
+function safeEqual(a, b) {
+  const hashA = createHash("sha256").update(a).digest();
+  const hashB = createHash("sha256").update(b).digest();
+  return timingSafeEqual(hashA, hashB);
+}
+export default defineEventHandler(async (event) => {
+  const ip = getRequestIP(event) ?? "unknown";
+  const now = Date.now();
+  pruneFailures(now);
+  if (globalFailures.resetAt > now && globalFailures.count >= RATE_GLOBAL_MAX_FAILURES) {
+    throw createError({
+      statusCode: 429,
+      statusMessage: "Too many failed attempts, try again later"
+    });
+  }
+  const attempts = failures.get(ip);
+  if (attempts && attempts.resetAt > now && 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 { adminEmail, adminPassword } = useRuntimeConfig(event).cms;
+  if (!adminEmail || !adminPassword) {
+    throw createError({ statusCode: 403, statusMessage: "Admin credentials are not configured" });
+  }
+  const emailOk = safeEqual(body.email.toLowerCase(), adminEmail.toLowerCase());
+  const passwordOk = safeEqual(body.password, adminPassword);
+  if (!emailOk || !passwordOk) {
+    const current = attempts && attempts.resetAt > now ? attempts : { count: 0, resetAt: now + RATE_WINDOW_MS };
+    current.count++;
+    failures.set(ip, current);
+    if (globalFailures.resetAt <= now)
+      globalFailures = { count: 0, resetAt: now + RATE_WINDOW_MS };
+    globalFailures.count++;
+    throw createError({ statusCode: 401, statusMessage: "Invalid credentials" });
+  }
+  failures.delete(ip);
+  await setUserSession(event, { user: { email: adminEmail.toLowerCase() } });
+  return { loggedIn: true };
+});

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

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

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

@@ -0,0 +1,34 @@
+import { createYoga } from "graphql-yoga";
+import { defineEventHandler } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { buildCmsSchema, createGraphqlContext } from "../utils/graphql.js";
+import { createBreadthRule, createDepthRule, createIntrospectionRule } from "../utils/graphql-depth.js";
+function buildYoga(options) {
+  return createYoga({
+    schema: buildCmsSchema(),
+    graphqlEndpoint: "/api/cms/graphql",
+    landingPage: false,
+    graphiql: options.graphiql,
+    cors: false,
+    context: () => createGraphqlContext(),
+    plugins: [
+      {
+        onValidate({
+          addValidationRule
+        }) {
+          addValidationRule(createDepthRule(options.maxDepth));
+          addValidationRule(createBreadthRule());
+          if (!options.graphiql) addValidationRule(createIntrospectionRule());
+        }
+      }
+    ]
+  });
+}
+let yoga = null;
+export default defineEventHandler((event) => {
+  if (!yoga) {
+    const { graphql } = useRuntimeConfig(event).cms;
+    yoga = buildYoga(graphql);
+  }
+  return yoga(event.node.req, event.node.res);
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+   "extends": "../../../.nuxt/tsconfig.server.json"
+}

package/dist/runtime/server/utils/custom-id.d.ts

@@ -0,0 +1,2 @@
+export declare const ID_LENGTH = 16;
+export declare function customId(prefix: string, length?: number): string;

package/dist/runtime/server/utils/custom-id.js

@@ -0,0 +1,10 @@
+import { randomInt } from "node:crypto";
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+export const ID_LENGTH = 16;
+export function customId(prefix, length = ID_LENGTH) {
+  let result = prefix ? `${prefix}_` : "";
+  for (let i = 0; i < length; i++) {
+    result += ALPHABET[randomInt(ALPHABET.length)];
+  }
+  return result;
+}

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

@@ -0,0 +1 @@
+export declare function mapConstraintErrors<T>(run: () => Promise<T>): Promise<T>;

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

@@ -0,0 +1,31 @@
+import { createError, isError } from "h3";
+const FK_CODES = /* @__PURE__ */ new Set(["SQLITE_CONSTRAINT_FOREIGNKEY", "23503"]);
+const UNIQUE_CODES = /* @__PURE__ */ new Set(["SQLITE_CONSTRAINT_UNIQUE", "SQLITE_CONSTRAINT_PRIMARYKEY", "23505"]);
+const NOT_NULL_CODES = /* @__PURE__ */ new Set(["SQLITE_CONSTRAINT_NOTNULL", "23502"]);
+export async function mapConstraintErrors(run) {
+  try {
+    return await run();
+  } catch (error) {
+    if (isError(error)) throw error;
+    const code = error?.code ?? "";
+    if (FK_CODES.has(code)) {
+      throw createError({
+        statusCode: 409,
+        statusMessage: "Operation conflicts with a relation: a referenced entry is missing or this entry is still referenced"
+      });
+    }
+    if (UNIQUE_CODES.has(code)) {
+      throw createError({
+        statusCode: 409,
+        statusMessage: "Duplicate value for a unique field"
+      });
+    }
+    if (NOT_NULL_CODES.has(code)) {
+      throw createError({
+        statusCode: 422,
+        statusMessage: "A required field is missing"
+      });
+    }
+    throw error;
+  }
+}

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

@@ -0,0 +1,3 @@
+export declare function useDb(): import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, unknown>> & {
+    $client: import("pg").Pool;
+};

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

@@ -0,0 +1,16 @@
+import { drizzle } from "drizzle-orm/node-postgres";
+import pg from "pg";
+import { useRuntimeConfig } from "#imports";
+let _db = null;
+export function useDb() {
+  if (!_db) {
+    const { databaseUrl } = useRuntimeConfig().cms;
+    if (!databaseUrl) {
+      throw new Error(
+        "[nuxt-cms] Missing Postgres connection string: set NUXT_CMS_DATABASE_URL or cms.database.url"
+      );
+    }
+    _db = drizzle(new pg.Pool({ connectionString: databaseUrl }));
+  }
+  return _db;
+}

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

@@ -0,0 +1,4 @@
+import Database from 'better-sqlite3';
+export declare function useDb(): import("drizzle-orm/better-sqlite3").BetterSQLite3Database<Record<string, unknown>> & {
+    $client: Database.Database;
+};

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

@@ -0,0 +1,17 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { useRuntimeConfig } from "#imports";
+let _db = null;
+export function useDb() {
+  if (!_db) {
+    const { dbPath } = useRuntimeConfig().cms;
+    mkdirSync(dirname(dbPath), { recursive: true });
+    const sqlite = new Database(dbPath);
+    sqlite.pragma("journal_mode = WAL");
+    sqlite.pragma("foreign_keys = ON");
+    _db = drizzle(sqlite);
+  }
+  return _db;
+}

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

@@ -0,0 +1,4 @@
+import type { ASTVisitor, ValidationContext } from 'graphql';
+export declare function createDepthRule(maxDepth?: number): (context: ValidationContext) => ASTVisitor;
+export declare function createBreadthRule(maxFields?: number): (context: ValidationContext) => ASTVisitor;
+export declare function createIntrospectionRule(): (context: ValidationContext) => ASTVisitor;