@xleddyl/nuxt-cms 0.1.9

package/dist/runtime/shared/graphql-sdl.js

@@ -0,0 +1,147 @@
+import { isTranslatableField } from "./index.js";
+export function typeName(name) {
+  return name.replace(/(?:^|_)([a-z0-9])/gi, (_, c) => c.toUpperCase());
+}
+export function blockUnionName(entryName, fieldKey) {
+  return `${typeName(entryName)}${typeName(fieldKey)}Block`;
+}
+export function blockTypeName(entryName, fieldKey, blockName) {
+  return `${typeName(entryName)}${typeName(fieldKey)}${typeName(blockName)}`;
+}
+function scalarFor(field) {
+  switch (field.type) {
+    case "number":
+      return field.integer ? "Int" : "Float";
+    case "boolean":
+      return "Boolean";
+    case "json":
+      return "JSON";
+    default:
+      return "String";
+  }
+}
+function filterScalarFor(field) {
+  if (isTranslatableField(field)) return null;
+  switch (field.type) {
+    case "json":
+      return null;
+    case "blocks":
+      return null;
+    case "relation":
+      return field.cardinality === "many-to-many" ? null : "StringFilter";
+    case "number":
+      return field.integer ? "IntFilter" : "FloatFilter";
+    case "boolean":
+      return "BooleanFilter";
+    default:
+      return "StringFilter";
+  }
+}
+function filterableKeys(entry) {
+  const keys = [["id", "StringFilter"]];
+  for (const [key, field] of Object.entries(entry.fields)) {
+    const scalar = filterScalarFor(field);
+    if (scalar) keys.push([key, scalar]);
+  }
+  keys.push(["createdAt", "StringFilter"], ["updatedAt", "StringFilter"]);
+  return keys;
+}
+function fieldSdl(config, entryName, key, field) {
+  if (field.type === "relation") {
+    const target = typeName(field.to);
+    if (field.cardinality === "many-to-many") return `  ${key}: [${target}!]!`;
+    const nonNull = field.required && !config[field.to]?.drafts;
+    return `  ${key}: ${target}${nonNull ? "!" : ""}`;
+  }
+  if (field.type === "media") return `  ${key}: CmsMedia`;
+  if (field.type === "blocks")
+    return `  ${key}: [${blockUnionName(entryName, key)}!]${field.required ? "!" : ""}`;
+  return `  ${key}: ${scalarFor(field)}${field.required ? "!" : ""}`;
+}
+function entrySdl(config, name, entry) {
+  const lines = ["  id: ID!"];
+  for (const [key, field] of Object.entries(entry.fields)) {
+    lines.push(fieldSdl(config, name, key, field));
+  }
+  if (entry.kind === "collection") lines.push("  createdAt: String!");
+  lines.push("  updatedAt: String!");
+  return `type ${typeName(name)} {
+${lines.join("\n")}
+}`;
+}
+function blocksSdl(name, key, field) {
+  const defs = [];
+  const members = [];
+  for (const [blockName, block] of Object.entries(field.blocks ?? {})) {
+    const gqlType = blockTypeName(name, key, blockName);
+    members.push(gqlType);
+    const lines = ["  type: String!"];
+    for (const [blockFieldKey, blockField] of Object.entries(block.fields)) {
+      if (blockField.type === "media") {
+        lines.push(`  ${blockFieldKey}: CmsMedia`);
+        continue;
+      }
+      lines.push(`  ${blockFieldKey}: ${scalarFor(blockField)}${blockField.required ? "!" : ""}`);
+    }
+    defs.push(`type ${gqlType} {
+${lines.join("\n")}
+}`);
+  }
+  if (members.length) defs.push(`union ${blockUnionName(name, key)} = ${members.join(" | ")}`);
+  return defs;
+}
+function filterSdl(name, entry) {
+  const gqlType = typeName(name);
+  const keys = filterableKeys(entry);
+  const filters = keys.map(([key, scalar]) => `  ${key}: ${scalar}`).join("\n");
+  const sortFields = keys.map(([key]) => `  ${key}`).join("\n");
+  return [
+    `input ${gqlType}Filters {
+${filters}
+}`,
+    `enum ${gqlType}SortField {
+${sortFields}
+}`,
+    `input ${gqlType}Sort {
+  field: ${gqlType}SortField!
+  direction: SortDirection = asc
+}`
+  ].join("\n\n");
+}
+const COMMON_SDL = [
+  "scalar JSON",
+  "enum SortDirection {\n  asc\n  desc\n}",
+  "input IntFilter {\n  eq: Int\n  neq: Int\n  gt: Int\n  gte: Int\n  lt: Int\n  lte: Int\n  in: [Int!]\n  isNull: Boolean\n}",
+  "input FloatFilter {\n  eq: Float\n  neq: Float\n  gt: Float\n  gte: Float\n  lt: Float\n  lte: Float\n  in: [Float!]\n  isNull: Boolean\n}",
+  "input StringFilter {\n  eq: String\n  neq: String\n  gt: String\n  gte: String\n  lt: String\n  lte: String\n  like: String\n  in: [String!]\n  isNull: Boolean\n}",
+  "input BooleanFilter {\n  eq: Boolean\n  neq: Boolean\n  isNull: Boolean\n}",
+  "type CmsMedia {\n  key: String!\n  url: String\n  type: String!\n  alt: String\n  folder: String\n  mime: String\n  size: Int\n  width: Int\n  height: Int\n}"
+];
+export function renderGraphqlSdl(config) {
+  const queryLines = [];
+  const types = [];
+  for (const [name, entry] of Object.entries(config)) {
+    const gqlType = typeName(name);
+    types.push(entrySdl(config, name, entry));
+    for (const [key, field] of Object.entries(entry.fields)) {
+      if (field.type === "blocks") types.push(...blocksSdl(name, key, field));
+    }
+    if (entry.kind === "single") {
+      queryLines.push(`  ${name}(locale: String): ${gqlType}`);
+      continue;
+    }
+    types.push(filterSdl(name, entry));
+    queryLines.push(
+      `  ${name}(filters: ${gqlType}Filters, sort: [${gqlType}Sort!], limit: Int, offset: Int, locale: String): [${gqlType}!]!`
+    );
+    queryLines.push(`  ${name}ById(id: ID!, locale: String): ${gqlType}`);
+    queryLines.push(`  ${name}Count(filters: ${gqlType}Filters): Int!`);
+  }
+  return [
+    ...COMMON_SDL,
+    ...types,
+    `type Query {
+${queryLines.length ? queryLines.join("\n") : "  _empty: Boolean"}
+}`
+  ].join("\n\n");
+}

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

@@ -0,0 +1,62 @@
+import type { PgTable } from 'drizzle-orm/pg-core';
+import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
+export type CmsTable = SQLiteTable | PgTable;
+export type FieldType = 'text' | 'richtext' | 'number' | 'boolean' | 'date' | 'email' | 'slug' | 'select' | 'json' | 'media' | 'relation' | 'blocks';
+export interface CmsI18n {
+    locales: string[];
+    defaultLocale: string;
+}
+export declare const MEDIA_TYPES: readonly ["image", "video", "file"];
+export type MediaType = (typeof MEDIA_TYPES)[number];
+export declare function mediaTypeForKey(key: string): MediaType;
+export declare function mediaFilename(key: string): string;
+export declare function mediaTypeFor(mime: string | null | undefined, key: string): MediaType;
+export declare function mediaIconFor(type: MediaType): string;
+export declare function mediaPublicUrl(baseUrl: string | null | undefined, key: string): string | null;
+export declare function slugify(value: string): string;
+export interface MediaItem {
+    id: number;
+    key: string;
+    alt: string | null;
+    folder: string | null;
+    mime: string | null;
+    size: number | null;
+    width: number | null;
+    height: number | null;
+    createdAt: string;
+    type: MediaType;
+    url: string | null;
+}
+export interface BlockConfig {
+    label: string;
+    fields: Record<string, FieldConfig>;
+}
+export interface FieldConfig {
+    label: string;
+    type: FieldType;
+    required?: boolean;
+    textarea?: boolean;
+    integer?: boolean;
+    translatable?: boolean;
+    options?: string[];
+    from?: string;
+    blocks?: Record<string, BlockConfig>;
+    mediaType?: MediaType;
+    accept?: string[];
+    to?: string;
+    cardinality?: 'many-to-one' | 'one-to-one' | 'many-to-many';
+    onDelete?: 'set null' | 'cascade' | 'restrict';
+}
+export declare function isTranslatableField(field: FieldConfig): boolean;
+export declare function translatableFieldKeys(entry: CmsEntry): string[];
+export interface CmsEntry {
+    id: string;
+    label: string;
+    kind: 'collection' | 'single';
+    titleField?: string;
+    drafts?: boolean;
+    fields: Record<string, FieldConfig>;
+    table?: CmsTable;
+}
+export type CmsConfig = Record<string, CmsEntry>;
+export declare function defineCmsConfig<T extends CmsConfig>(config: T): T;

package/dist/runtime/shared/index.js

@@ -0,0 +1,55 @@
+export const MEDIA_TYPES = ["image", "video", "file"];
+const MEDIA_EXTENSIONS = {
+  image: [
+    "apng",
+    "avif",
+    "bmp",
+    "gif",
+    "heic",
+    "ico",
+    "jpeg",
+    "jpg",
+    "png",
+    "svg",
+    "tif",
+    "tiff",
+    "webp"
+  ],
+  video: ["avi", "m4v", "mkv", "mov", "mp4", "mpeg", "mpg", "ogv", "webm"]
+};
+export function mediaTypeForKey(key) {
+  const dot = key.lastIndexOf(".");
+  if (dot === -1) return "file";
+  const ext = key.slice(dot + 1).toLowerCase();
+  if (MEDIA_EXTENSIONS.image.includes(ext)) return "image";
+  if (MEDIA_EXTENSIONS.video.includes(ext)) return "video";
+  return "file";
+}
+export function mediaFilename(key) {
+  const base = key.split("/").pop() ?? key;
+  return base.replace(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}-/i, "");
+}
+export function mediaTypeFor(mime, key) {
+  if (mime?.startsWith("image/")) return "image";
+  if (mime?.startsWith("video/")) return "video";
+  if (mime) return "file";
+  return mediaTypeForKey(key);
+}
+export function mediaIconFor(type) {
+  return type === "image" ? "i-lucide-image" : type === "video" ? "i-lucide-film" : "i-lucide-file";
+}
+export function mediaPublicUrl(baseUrl, key) {
+  return baseUrl ? `${baseUrl.replace(/\/+$/, "")}/${key}` : null;
+}
+export function slugify(value) {
+  return value.toLowerCase().normalize("NFKD").replace(/[\u0300-\u036F]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+export function isTranslatableField(field) {
+  return !!field.translatable && (field.type === "text" || field.type === "richtext");
+}
+export function translatableFieldKeys(entry) {
+  return Object.entries(entry.fields).filter(([, field]) => isTranslatableField(field)).map(([key]) => key);
+}
+export function defineCmsConfig(config) {
+  return config;
+}

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { CmsEntry, CmsI18n } from './index.js';
+export declare const objectKeySchema: z.ZodString;
+export interface ValidationMessages {
+    required: string;
+    invalidDate: string;
+    invalidEmail: string;
+    invalidSlug: string;
+    unknownLocale: string;
+    requiredLocale: (locale: string) => string;
+}
+export declare function buildEntrySchema(entry: Pick<CmsEntry, 'fields'> & {
+    drafts?: boolean;
+}, i18n: CmsI18n, messages?: Partial<ValidationMessages>): z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>;

package/dist/runtime/shared/validation.js

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { isTranslatableField } from "./index.js";
+export const objectKeySchema = z.string().min(1).max(1024).refine((k) => !k.includes("..") && !k.startsWith("/"), "Invalid object key");
+const DEFAULT_MESSAGES = {
+  required: "Required field",
+  invalidDate: "Invalid date (yyyy-mm-dd)",
+  invalidEmail: "Invalid email",
+  invalidSlug: "Invalid slug (lowercase letters, numbers, dashes)",
+  unknownLocale: "Unknown locale key",
+  requiredLocale: (locale) => `Required field (locale '${locale}')`
+};
+function scalarSchema(field, m) {
+  switch (field.type) {
+    case "number":
+      return field.integer ? z.number().int() : z.number();
+    case "boolean":
+      return z.boolean();
+    case "relation":
+      return z.string().min(1);
+    case "date":
+      return z.string().regex(/^\d{4}-\d{2}-\d{2}$/, m.invalidDate);
+    case "email":
+      return z.email(m.invalidEmail);
+    case "slug":
+      return z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, m.invalidSlug);
+    case "select":
+      return z.enum(field.options);
+    case "media":
+      return objectKeySchema;
+    default:
+      return field.required ? z.string().trim().min(1, m.required) : z.string();
+  }
+}
+function optionalize(field, base) {
+  return field.required ? base : base.nullish().transform((v) => v ?? null);
+}
+function blocksSchema(field, m) {
+  const variants = Object.entries(field.blocks ?? {}).map(
+    ([type, block]) => z.object({
+      type: z.literal(type),
+      ...Object.fromEntries(
+        Object.entries(block.fields).map(([key, blockField]) => [
+          key,
+          optionalize(blockField, scalarSchema(blockField, m))
+        ])
+      )
+    })
+  );
+  return z.array(z.discriminatedUnion("type", variants));
+}
+export function buildEntrySchema(entry, i18n, messages) {
+  const m = { ...DEFAULT_MESSAGES, ...messages };
+  const { locales, defaultLocale } = i18n;
+  const shape = {};
+  for (const [key, field] of Object.entries(entry.fields)) {
+    if (field.type === "relation" && field.cardinality === "many-to-many") {
+      const list = z.array(z.string().min(1));
+      shape[key] = field.required ? list.min(1, m.required) : list.nullish().transform((v) => v ?? []);
+      continue;
+    }
+    if (field.type === "blocks") {
+      const list = blocksSchema(field, m);
+      shape[key] = field.required ? list.min(1, m.required) : list.nullish().transform((v) => v ?? null);
+      continue;
+    }
+    if (isTranslatableField(field) && locales.length) {
+      const record = z.record(z.string(), z.string()).refine((v) => Object.keys(v).every((k) => locales.includes(k)), m.unknownLocale);
+      shape[key] = field.required ? record.refine((v) => !!v[defaultLocale]?.trim(), m.requiredLocale(defaultLocale)) : record.nullish().transform((v) => v ?? null);
+      continue;
+    }
+    if (field.type === "json") {
+      const json = z.unknown();
+      shape[key] = field.required ? json.refine((v) => v !== void 0 && v !== null, m.required) : json.nullish().transform((v) => v ?? null);
+      continue;
+    }
+    shape[key] = optionalize(field, scalarSchema(field, m));
+  }
+  if (entry.drafts) {
+    shape.status = z.enum(["draft", "published"]).nullish().transform((v) => v ?? void 0);
+  }
+  return z.object(shape);
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@xleddyl/nuxt-cms",
+  "version": "0.1.9",
+  "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)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xleddyl/nuxt-cms"
+  },
+  "homepage": "https://github.com/xleddyl/nuxt-cms#readme",
+  "bugs": {
+    "url": "https://github.com/xleddyl/nuxt-cms/issues"
+  },
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "nitro",
+    "cms",
+    "headless-cms",
+    "self-hosted",
+    "sqlite",
+    "postgres",
+    "drizzle",
+    "graphql"
+  ],
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nuxt/kit": "^4.4.8",
+    "@nuxt/ui": "^4.0.0",
+    "@nuxtjs/i18n": "^10.4.0",
+    "@tiptap/starter-kit": "^3.0.0",
+    "@tiptap/vue-3": "^3.0.0",
+    "aws4fetch": "^1.0.20",
+    "better-sqlite3": "^12.2.0",
+    "drizzle-kit": "^0.31.0",
+    "drizzle-orm": "^0.44.0",
+    "gql.tada": "^1.11.2",
+    "graphql": "^16.11.0",
+    "graphql-yoga": "^5.10.0",
+    "jiti": "^2.7.0",
+    "nuxt-auth-utils": "^0.5.29",
+    "pg": "^8.16.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.2.4",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.4.8",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "latest",
+    "@types/pg": "^8.11.0",
+    "changelogen": "^0.6.0",
+    "nuxt": "^4.4.8",
+    "prettier": "3.1.1",
+    "prettier-plugin-tailwindcss": "0.6.11",
+    "typescript": "~6.0.3",
+    "vue-tsc": "^3.3.3"
+  },
+  "scripts": {
+    "dev": "pnpm dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "db:studio": "drizzle-kit studio --config=playground/.nuxt/cms/drizzle.config.ts",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
+    "format": "prettier --write \"**/*.{ts,tsx,js,jsx,md,html,json,sql,vue}\" --log-level error",
+    "release": "changelogen --release --push"
+  }
+}