gavaengine 0.1.2 → 2.0.0

package/dist/handlers/index.js

@@ -1,4 +1,317 @@
+// src/i18n/it.ts
+var it = {
+  content: {
+    articles: "Articoli",
+    newArticle: "Nuovo articolo",
+    titlePlaceholder: "Titolo dell'articolo",
+    excerptPlaceholder: "Breve descrizione dell'articolo...",
+    slugPlaceholder: "slug-articolo",
+    authorPlaceholder: "Nome dell'autore",
+    category: "Categoria",
+    selectCategory: "Seleziona categoria",
+    excerpt: "Estratto",
+    author: "Autore",
+    slugUrl: "Slug URL",
+    noArticles: "Nessun articolo.",
+    noArticlesSearch: "Nessun articolo trovato.",
+    searchArticles: "Cerca articoli...",
+    coverImageLabel: "Immagine di copertina",
+    coverImageHint: "Scegli dalla libreria o carica un nuovo file",
+    viewArticle: "Vedi articolo pubblicato",
+    untitled: "Senza titolo"
+  },
+  editor: {
+    publish: "Pubblica",
+    unpublish: "Ritira",
+    saveDraft: "Salva bozza",
+    revisions: "Cronologia",
+    saving: "Salvando...",
+    saved: "Salvato",
+    saveError: "Errore nel salvataggio",
+    noRevisions: "Nessuna revisione salvata.",
+    restore: "Ripristina",
+    restoreConfirm: "Ripristinare questa revisione? Lo stato attuale verr\xE0 salvato prima del ripristino.",
+    beforeRestore: "Prima del ripristino",
+    publishedNote: "Pubblicato",
+    preview: "Anteprima",
+    placeholder: "Inizia a scrivere il tuo articolo..."
+  },
+  media: {
+    media: "Media",
+    noMedia: "Nessun file caricato.",
+    noMediaSearch: "Nessun file trovato.",
+    chooseFile: "Scegli file",
+    dragHint: "Trascina un'immagine qui oppure",
+    uploadHint: "JPEG, PNG, WebP, GIF (max 5MB)",
+    mediaLibrary: "Libreria media",
+    uploadNew: "Carica nuovo",
+    searchFiles: "Cerca file...",
+    selectImage: "Seleziona immagine",
+    noImages: "Nessuna immagine nella libreria.",
+    noImagesSearch: "Nessuna immagine trovata.",
+    copyUrl: "Copia URL",
+    editImage: "Modifica immagine",
+    restoreOriginal: "Ripristina originale",
+    freeAspect: "Libero"
+  },
+  users: {
+    users: "Utenti",
+    name: "Nome",
+    email: "Email",
+    password: "Password",
+    passwordEditHint: " (lascia vuoto per non modificarla)",
+    role: "Ruolo",
+    createdAt: "Creato il",
+    actions: "Azioni",
+    createUser: "Crea utente",
+    unauthorized: "Non autorizzato",
+    notAuthenticated: "Non autenticato",
+    allFieldsRequired: "Tutti i campi sono obbligatori.",
+    passwordMinLength: "La password deve avere almeno 6 caratteri.",
+    emailExists: "Esiste gi\xE0 un utente con questa email.",
+    invalidRole: "Ruolo non valido.",
+    cannotDeleteSelf: "Non puoi eliminare il tuo stesso account."
+  },
+  common: {
+    statistics: "Statistiche",
+    settings: "Impostazioni",
+    delete: "Elimina",
+    edit: "Modifica",
+    search: "Cerca",
+    draft: "Bozza",
+    published: "Pubblicato",
+    all: "Tutti",
+    drafts: "Bozze",
+    loading: "Caricamento...",
+    confirm: "Conferma",
+    cancel: "Annulla",
+    apply: "Applica",
+    change: "Cambia",
+    logout: "Esci",
+    saveChanges: "Salva modifiche",
+    updated: "Aggiornato",
+    status: "Stato",
+    title: "Titolo",
+    deleteConfirm: (title) => `Eliminare "${title || "Senza titolo"}"?`,
+    unpublishConfirm: (title) => `Ritirare "${title || "Senza titolo"}"? L'articolo torner\xE0 in bozza.`,
+    deleteUserConfirm: (name) => `Sei sicuro di voler eliminare l'utente "${name}"?`,
+    totalArticles: (count) => `${count} articol${count === 1 ? "o" : "i"} totali`,
+    totalFiles: (count) => `${count} file caricati`
+  }
+};
+
+// src/i18n/en.ts
+var en = {
+  content: {
+    articles: "Articles",
+    newArticle: "New article",
+    titlePlaceholder: "Article title",
+    excerptPlaceholder: "Brief description of the article...",
+    slugPlaceholder: "article-slug",
+    authorPlaceholder: "Author name",
+    category: "Category",
+    selectCategory: "Select category",
+    excerpt: "Excerpt",
+    author: "Author",
+    slugUrl: "URL Slug",
+    noArticles: "No articles.",
+    noArticlesSearch: "No articles found.",
+    searchArticles: "Search articles...",
+    coverImageLabel: "Cover image",
+    coverImageHint: "Choose from library or upload a new file",
+    viewArticle: "View published article",
+    untitled: "Untitled"
+  },
+  editor: {
+    publish: "Publish",
+    unpublish: "Unpublish",
+    saveDraft: "Save draft",
+    revisions: "History",
+    saving: "Saving...",
+    saved: "Saved",
+    saveError: "Error saving",
+    noRevisions: "No revisions saved.",
+    restore: "Restore",
+    restoreConfirm: "Restore this revision? The current state will be saved before restoring.",
+    beforeRestore: "Before restore",
+    publishedNote: "Published",
+    preview: "Preview",
+    placeholder: "Start writing your article..."
+  },
+  media: {
+    media: "Media",
+    noMedia: "No files uploaded.",
+    noMediaSearch: "No files found.",
+    chooseFile: "Choose file",
+    dragHint: "Drag an image here or",
+    uploadHint: "JPEG, PNG, WebP, GIF (max 5MB)",
+    mediaLibrary: "Media library",
+    uploadNew: "Upload new",
+    searchFiles: "Search files...",
+    selectImage: "Select image",
+    noImages: "No images in library.",
+    noImagesSearch: "No images found.",
+    copyUrl: "Copy URL",
+    editImage: "Edit image",
+    restoreOriginal: "Restore original",
+    freeAspect: "Free"
+  },
+  users: {
+    users: "Users",
+    name: "Name",
+    email: "Email",
+    password: "Password",
+    passwordEditHint: " (leave blank to keep current)",
+    role: "Role",
+    createdAt: "Created at",
+    actions: "Actions",
+    createUser: "Create user",
+    unauthorized: "Unauthorized",
+    notAuthenticated: "Not authenticated",
+    allFieldsRequired: "All fields are required.",
+    passwordMinLength: "Password must be at least 6 characters.",
+    emailExists: "A user with this email already exists.",
+    invalidRole: "Invalid role.",
+    cannotDeleteSelf: "You cannot delete your own account."
+  },
+  common: {
+    statistics: "Statistics",
+    settings: "Settings",
+    delete: "Delete",
+    edit: "Edit",
+    search: "Search",
+    draft: "Draft",
+    published: "Published",
+    all: "All",
+    drafts: "Drafts",
+    loading: "Loading...",
+    confirm: "Confirm",
+    cancel: "Cancel",
+    apply: "Apply",
+    change: "Change",
+    logout: "Logout",
+    saveChanges: "Save changes",
+    updated: "Updated",
+    status: "Status",
+    title: "Title",
+    deleteConfirm: (title) => `Delete "${title || "Untitled"}"?`,
+    unpublishConfirm: (title) => `Unpublish "${title || "Untitled"}"? The article will go back to draft.`,
+    deleteUserConfirm: (name) => `Are you sure you want to delete user "${name}"?`,
+    totalArticles: (count) => `${count} total article${count === 1 ? "" : "s"}`,
+    totalFiles: (count) => `${count} uploaded file${count === 1 ? "" : "s"}`
+  }
+};
+
+// src/i18n/index.ts
+var builtinLocales = { it, en };
+function loadLocale(locale) {
+  const found = builtinLocales[locale];
+  if (!found) {
+    throw new Error(
+      `Locale "${locale}" not found. Available: ${Object.keys(builtinLocales).join(", ")}`
+    );
+  }
+  return found;
+}
+
 // src/config.ts
+function localeToStrings(locale) {
+  return {
+    // content
+    articles: locale.content.articles,
+    newArticle: locale.content.newArticle,
+    titlePlaceholder: locale.content.titlePlaceholder,
+    excerptPlaceholder: locale.content.excerptPlaceholder,
+    slugPlaceholder: locale.content.slugPlaceholder,
+    authorPlaceholder: locale.content.authorPlaceholder,
+    category: locale.content.category,
+    selectCategory: locale.content.selectCategory,
+    excerpt: locale.content.excerpt,
+    author: locale.content.author,
+    slugUrl: locale.content.slugUrl,
+    noArticles: locale.content.noArticles,
+    noArticlesSearch: locale.content.noArticlesSearch,
+    searchArticles: locale.content.searchArticles,
+    coverImageLabel: locale.content.coverImageLabel,
+    coverImageHint: locale.content.coverImageHint,
+    viewArticle: locale.content.viewArticle,
+    untitled: locale.content.untitled,
+    // editor
+    publish: locale.editor.publish,
+    unpublish: locale.editor.unpublish,
+    saveDraft: locale.editor.saveDraft,
+    revisions: locale.editor.revisions,
+    saving: locale.editor.saving,
+    saved: locale.editor.saved,
+    saveError: locale.editor.saveError,
+    noRevisions: locale.editor.noRevisions,
+    restore: locale.editor.restore,
+    restoreConfirm: locale.editor.restoreConfirm,
+    beforeRestore: locale.editor.beforeRestore,
+    publishedNote: locale.editor.publishedNote,
+    preview: locale.editor.preview,
+    // media
+    media: locale.media.media,
+    noMedia: locale.media.noMedia,
+    noMediaSearch: locale.media.noMediaSearch,
+    chooseFile: locale.media.chooseFile,
+    dragHint: locale.media.dragHint,
+    uploadHint: locale.media.uploadHint,
+    mediaLibrary: locale.media.mediaLibrary,
+    uploadNew: locale.media.uploadNew,
+    searchFiles: locale.media.searchFiles,
+    selectImage: locale.media.selectImage,
+    noImages: locale.media.noImages,
+    noImagesSearch: locale.media.noImagesSearch,
+    copyUrl: locale.media.copyUrl,
+    editImage: locale.media.editImage,
+    restoreOriginal: locale.media.restoreOriginal,
+    freeAspect: locale.media.freeAspect,
+    // users
+    users: locale.users.users,
+    name: locale.users.name,
+    email: locale.users.email,
+    password: locale.users.password,
+    passwordEditHint: locale.users.passwordEditHint,
+    role: locale.users.role,
+    createdAt: locale.users.createdAt,
+    actions: locale.users.actions,
+    createUser: locale.users.createUser,
+    unauthorized: locale.users.unauthorized,
+    notAuthenticated: locale.users.notAuthenticated,
+    allFieldsRequired: locale.users.allFieldsRequired,
+    passwordMinLength: locale.users.passwordMinLength,
+    emailExists: locale.users.emailExists,
+    invalidRole: locale.users.invalidRole,
+    cannotDeleteSelf: locale.users.cannotDeleteSelf,
+    // common
+    statistics: locale.common.statistics,
+    settings: locale.common.settings,
+    delete: locale.common.delete,
+    edit: locale.common.edit,
+    search: locale.common.search,
+    draft: locale.common.draft,
+    published: locale.common.published,
+    all: locale.common.all,
+    drafts: locale.common.drafts,
+    loading: locale.common.loading,
+    confirm: locale.common.confirm,
+    cancel: locale.common.cancel,
+    apply: locale.common.apply,
+    change: locale.common.change,
+    logout: locale.common.logout,
+    saveChanges: locale.common.saveChanges,
+    updated: locale.common.updated,
+    status: locale.common.status,
+    title: locale.common.title,
+    deleteConfirm: locale.common.deleteConfirm,
+    unpublishConfirm: locale.common.unpublishConfirm,
+    deleteUserConfirm: locale.common.deleteUserConfirm,
+    totalArticles: locale.common.totalArticles,
+    totalFiles: locale.common.totalFiles
+  };
+}
+var DEFAULT_STRINGS = localeToStrings(loadLocale("it"));
 var DEFAULT_CONFIG = {
   branding: {
     name: "GavaEngine"
@@ -15,6 +328,18 @@ var DEFAULT_CONFIG = {
     canPublish: (role) => role === "admin" || role === "redattore",
     adminRole: "admin"
   },
+  statuses: {
+    draft: "bozza",
+    published: "pubblicato"
+  },
+  locale: "it",
+  models: {
+    article: "article",
+    articleRevision: "articleRevision",
+    articleView: "articleView",
+    media: "media",
+    user: "user"
+  },
   categories: [
     "Cultura ed Intercultura",
     "Fatti ed Eventi",
@@ -49,95 +374,7 @@ var DEFAULT_CONFIG = {
     login: "/login",
     home: "/"
   },
-  strings: {
-    articles: "Articoli",
-    newArticle: "Nuovo articolo",
-    media: "Media",
-    users: "Utenti",
-    statistics: "Statistiche",
-    settings: "Impostazioni",
-    revisions: "Cronologia",
-    publish: "Pubblica",
-    unpublish: "Ritira",
-    saveDraft: "Salva bozza",
-    delete: "Elimina",
-    edit: "Modifica",
-    search: "Cerca",
-    titlePlaceholder: "Titolo dell'articolo",
-    excerptPlaceholder: "Breve descrizione dell'articolo...",
-    slugPlaceholder: "slug-articolo",
-    authorPlaceholder: "Nome dell'autore",
-    category: "Categoria",
-    selectCategory: "Seleziona categoria",
-    excerpt: "Estratto",
-    author: "Autore",
-    slugUrl: "Slug URL",
-    draft: "Bozza",
-    published: "Pubblicato",
-    all: "Tutti",
-    drafts: "Bozze",
-    saving: "Salvando...",
-    saved: "Salvato",
-    saveError: "Errore nel salvataggio",
-    noArticles: "Nessun articolo.",
-    noArticlesSearch: "Nessun articolo trovato.",
-    noMedia: "Nessun file caricato.",
-    noMediaSearch: "Nessun file trovato.",
-    noRevisions: "Nessuna revisione salvata.",
-    loading: "Caricamento...",
-    confirm: "Conferma",
-    cancel: "Annulla",
-    apply: "Applica",
-    change: "Cambia",
-    logout: "Esci",
-    viewArticle: "Vedi articolo pubblicato",
-    preview: "Anteprima",
-    restore: "Ripristina",
-    restoreConfirm: "Ripristinare questa revisione? Lo stato attuale verr\xE0 salvato prima del ripristino.",
-    beforeRestore: "Prima del ripristino",
-    publishedNote: "Pubblicato",
-    deleteConfirm: (title) => `Eliminare "${title || "Senza titolo"}"?`,
-    unpublishConfirm: (title) => `Ritirare "${title || "Senza titolo"}"? L'articolo torner\xE0 in bozza.`,
-    deleteUserConfirm: (name) => `Sei sicuro di voler eliminare l'utente "${name}"?`,
-    totalArticles: (count) => `${count} articol${count === 1 ? "o" : "i"} totali`,
-    totalFiles: (count) => `${count} file caricati`,
-    coverImageLabel: "Immagine di copertina",
-    coverImageHint: "Scegli dalla libreria o carica un nuovo file",
-    chooseFile: "Scegli file",
-    dragHint: "Trascina un'immagine qui oppure",
-    uploadHint: "JPEG, PNG, WebP, GIF (max 5MB)",
-    mediaLibrary: "Libreria media",
-    uploadNew: "Carica nuovo",
-    searchFiles: "Cerca file...",
-    searchArticles: "Cerca articoli...",
-    selectImage: "Seleziona immagine",
-    noImages: "Nessuna immagine nella libreria.",
-    noImagesSearch: "Nessuna immagine trovata.",
-    copyUrl: "Copia URL",
-    editImage: "Modifica immagine",
-    restoreOriginal: "Ripristina originale",
-    freeAspect: "Libero",
-    unauthorized: "Non autorizzato",
-    notAuthenticated: "Non autenticato",
-    allFieldsRequired: "Tutti i campi sono obbligatori.",
-    passwordMinLength: "La password deve avere almeno 6 caratteri.",
-    emailExists: "Esiste gi\xE0 un utente con questa email.",
-    invalidRole: "Ruolo non valido.",
-    cannotDeleteSelf: "Non puoi eliminare il tuo stesso account.",
-    name: "Nome",
-    email: "Email",
-    password: "Password",
-    passwordEditHint: " (lascia vuoto per non modificarla)",
-    role: "Ruolo",
-    createdAt: "Creato il",
-    actions: "Azioni",
-    createUser: "Crea utente",
-    saveChanges: "Salva modifiche",
-    updated: "Aggiornato",
-    status: "Stato",
-    title: "Titolo",
-    untitled: "Senza titolo"
-  }
+  strings: DEFAULT_STRINGS
 };
 function deepMerge(target, source) {
   const result = { ...target };
@@ -156,32 +393,47 @@ function deepMerge(target, source) {
   return result;
 }
 function defineConfig(overrides = {}) {
-  return deepMerge(DEFAULT_CONFIG, overrides);
+  const locale = overrides.locale ?? DEFAULT_CONFIG.locale;
+  const baseStrings = localeToStrings(loadLocale(locale));
+  const configWithLocale = {
+    ...DEFAULT_CONFIG,
+    strings: baseStrings
+  };
+  if (!overrides.editor?.placeholder) {
+    const localeData = loadLocale(locale);
+    configWithLocale.editor = {
+      ...configWithLocale.editor,
+      placeholder: localeData.editor.placeholder
+    };
+  }
+  return deepMerge(configWithLocale, overrides);
 }
 
 // src/handlers/revisions.ts
 function createRevisionHandlers(prisma, config) {
   const throttleMs = config.editor.revisionThrottleMinutes * 60 * 1e3;
+  const articleModel = config.models.article;
+  const revisionModel = config.models.articleRevision;
   return {
     async getRevisions(articleId) {
-      return prisma.articleRevision.findMany({
+      return prisma[revisionModel].findMany({
         where: { articleId },
         include: { editor: { select: { name: true } } },
         orderBy: { createdAt: "desc" }
       });
     },
     async restoreRevision(articleId, revisionId, editorId) {
-      const article = await prisma.article.findUnique({
+      const article = await prisma[articleModel].findUnique({
         where: { id: articleId }
       });
       if (!article) throw new Error("Article not found");
-      const revision = await prisma.articleRevision.findUnique({
+      const revision = await prisma[revisionModel].findUnique({
         where: { id: revisionId }
       });
       if (!revision || revision.articleId !== articleId) {
         throw new Error("Revision not found");
       }
-      await prisma.articleRevision.create({
+      await prisma[revisionModel].create({
         data: {
           articleId,
           title: article.title,
@@ -193,7 +445,7 @@ function createRevisionHandlers(prisma, config) {
           note: config.strings.beforeRestore
         }
       });
-      await prisma.article.update({
+      await prisma[articleModel].update({
         where: { id: articleId },
         data: {
           title: revision.title,
@@ -207,17 +459,17 @@ function createRevisionHandlers(prisma, config) {
       return { success: true };
     },
     async createRevisionSnapshot(articleId, editorId, note = "") {
-      const article = await prisma.article.findUnique({
+      const article = await prisma[articleModel].findUnique({
         where: { id: articleId }
       });
       if (!article) return;
       const threshold = new Date(Date.now() - throttleMs);
-      const recent = await prisma.articleRevision.findFirst({
+      const recent = await prisma[revisionModel].findFirst({
         where: { articleId, createdAt: { gte: threshold } },
         orderBy: { createdAt: "desc" }
       });
       if (recent && !note) return;
-      await prisma.articleRevision.create({
+      await prisma[revisionModel].create({
         data: {
           articleId,
           title: article.title,
@@ -236,19 +488,20 @@ function createRevisionHandlers(prisma, config) {
 // src/handlers/articles.ts
 function createArticleHandlers(prisma, config) {
   const revisionHandlers = createRevisionHandlers(prisma, config);
+  const articleModel = config.models.article;
   return {
     async getArticles() {
-      return prisma.article.findMany({
+      return prisma[articleModel].findMany({
         orderBy: { updatedAt: "desc" }
       });
     },
     async getArticleById(id) {
-      return prisma.article.findUnique({
+      return prisma[articleModel].findUnique({
         where: { id }
       });
     },
     async createArticle(authorName) {
-      const article = await prisma.article.create({
+      const article = await prisma[articleModel].create({
         data: {
           authorName
         }
@@ -256,23 +509,23 @@ function createArticleHandlers(prisma, config) {
       return article.id;
     },
     async updateArticle(userId, id, data) {
-      const article = await prisma.article.findUnique({ where: { id } });
+      const article = await prisma[articleModel].findUnique({ where: { id } });
       if (!article) throw new Error("Article not found");
       await revisionHandlers.createRevisionSnapshot(id, userId);
-      await prisma.article.update({
+      await prisma[articleModel].update({
         where: { id },
         data: { ...data, updatedAt: /* @__PURE__ */ new Date() }
       });
       return { success: true };
     },
     async deleteArticle(id) {
-      const article = await prisma.article.findUnique({ where: { id } });
+      const article = await prisma[articleModel].findUnique({ where: { id } });
       if (!article) throw new Error("Article not found");
-      await prisma.article.delete({ where: { id } });
+      await prisma[articleModel].delete({ where: { id } });
       return { success: true };
     },
     async publishArticle(userId, id) {
-      const article = await prisma.article.findUnique({ where: { id } });
+      const article = await prisma[articleModel].findUnique({ where: { id } });
       if (!article) throw new Error("Article not found");
       if (!article.title || !article.slug) {
         throw new Error(
@@ -284,22 +537,22 @@ function createArticleHandlers(prisma, config) {
         userId,
         config.strings.publishedNote
       );
-      await prisma.article.update({
+      await prisma[articleModel].update({
         where: { id },
         data: {
-          status: "pubblicato",
+          status: config.statuses.published,
           publishedAt: /* @__PURE__ */ new Date()
         }
       });
       return { success: true };
     },
     async unpublishArticle(id) {
-      const article = await prisma.article.findUnique({ where: { id } });
+      const article = await prisma[articleModel].findUnique({ where: { id } });
       if (!article) throw new Error("Article not found");
-      await prisma.article.update({
+      await prisma[articleModel].update({
         where: { id },
         data: {
-          status: "bozza",
+          status: config.statuses.draft,
           publishedAt: null
         }
       });
@@ -311,9 +564,10 @@ function createArticleHandlers(prisma, config) {
 // src/handlers/users.ts
 import bcrypt from "bcryptjs";
 function createUserHandlers(prisma, config) {
+  const userModel = config.models.user;
   return {
     async getUsers() {
-      return prisma.user.findMany({
+      return prisma[userModel].findMany({
         select: {
           id: true,
           name: true,
@@ -325,7 +579,7 @@ function createUserHandlers(prisma, config) {
       });
     },
     async getUserById(id) {
-      return prisma.user.findUnique({
+      return prisma[userModel].findUnique({
         where: { id },
         select: {
           id: true,
@@ -349,12 +603,12 @@ function createUserHandlers(prisma, config) {
       if (password.length < 6) {
         return { error: config.strings.passwordMinLength };
       }
-      const existing = await prisma.user.findUnique({ where: { email } });
+      const existing = await prisma[userModel].findUnique({ where: { email } });
       if (existing) {
         return { error: config.strings.emailExists };
       }
       const hashedPassword = await bcrypt.hash(password, 10);
-      await prisma.user.create({
+      await prisma[userModel].create({
         data: {
           name,
           email,
@@ -375,7 +629,7 @@ function createUserHandlers(prisma, config) {
       if (!config.roles.list.includes(role)) {
         return { error: config.strings.invalidRole };
       }
-      const existing = await prisma.user.findUnique({ where: { email } });
+      const existing = await prisma[userModel].findUnique({ where: { email } });
       if (existing && existing.id !== id) {
         return { error: config.strings.emailExists };
       }
@@ -390,7 +644,7 @@ function createUserHandlers(prisma, config) {
         }
         data.password = await bcrypt.hash(password, 10);
       }
-      await prisma.user.update({
+      await prisma[userModel].update({
         where: { id },
         data
       });
@@ -400,29 +654,31 @@ function createUserHandlers(prisma, config) {
       if (currentUserId === id) {
         return { error: config.strings.cannotDeleteSelf };
       }
-      await prisma.user.delete({ where: { id } });
+      await prisma[userModel].delete({ where: { id } });
       return { success: true };
     }
   };
 }
 
 // src/handlers/media.ts
-function createMediaHandlers(prisma, _config) {
+function createMediaHandlers(prisma, config) {
+  const mediaModel = config.models.media;
+  const articleModel = config.models.article;
   return {
     async getMedia(search) {
-      return prisma.media.findMany({
+      return prisma[mediaModel].findMany({
         where: search ? { filename: { contains: search } } : void 0,
         include: { uploader: { select: { name: true } } },
         orderBy: { createdAt: "desc" }
       });
     },
     async deleteMedia(userId, userRole, id, deleteFileFromDisk) {
-      const media = await prisma.media.findUnique({ where: { id } });
+      const media = await prisma[mediaModel].findUnique({ where: { id } });
       if (!media) throw new Error("File not found");
       if (userRole === "scrittore" && media.uploaderId !== userId) {
         throw new Error("Unauthorized");
       }
-      const usedInArticles = await prisma.article.findMany({
+      const usedInArticles = await prisma[articleModel].findMany({
         where: {
           OR: [
             { coverImage: media.path },
@@ -443,7 +699,7 @@ function createMediaHandlers(prisma, _config) {
         } catch {
         }
       }
-      await prisma.media.delete({ where: { id } });
+      await prisma[mediaModel].delete({ where: { id } });
       return { success: true };
     }
   };
@@ -455,6 +711,7 @@ function createUploadHandler(prisma, config, storage) {
     ...config.upload.imageTypes,
     ...config.upload.videoTypes
   ];
+  const mediaModel = config.models.media;
   return {
     async handleUpload(file, uploaderId) {
       if (!allowedTypes.includes(file.type)) {
@@ -469,7 +726,7 @@ function createUploadHandler(prisma, config, storage) {
       }
       const buffer = Buffer.from(await file.arrayBuffer());
       const url = await storage.save(file.name, buffer, file.type);
-      await prisma.media.create({
+      await prisma[mediaModel].create({
         data: {
           filename: file.name,
           path: url,
@@ -485,7 +742,8 @@ function createUploadHandler(prisma, config, storage) {
 
 // src/handlers/auth.ts
 import bcrypt2 from "bcryptjs";
-function buildCredentialsProvider(prisma) {
+function buildCredentialsProvider(prisma, config) {
+  const userModel = config?.models?.user ?? "user";
   return {
     credentials: {
       email: {},
@@ -495,7 +753,7 @@ function buildCredentialsProvider(prisma) {
       const email = credentials.email;
       const password = credentials.password;
       if (!email || !password) return null;
-      const user = await prisma.user.findUnique({
+      const user = await prisma[userModel].findUnique({
         where: { email }
       });
       if (!user) return null;
@@ -571,12 +829,105 @@ function createAuthUtils(config) {
     }
   };
 }
+
+// src/handlers/content.ts
+function createContentHandlers(prisma, contentType, config) {
+  const modelName = contentType.slug.replace(/s$/, "").replace(/(^|\-)(\w)/g, (_m, _p1, p2) => p2.toUpperCase());
+  const model = prisma[modelName] ?? prisma[contentType.slug];
+  if (!model) {
+    throw new Error(
+      `Prisma model "${modelName}" not found for content type "${contentType.slug}"`
+    );
+  }
+  const defaultSort = contentType.admin?.defaultSort ? { [contentType.admin.defaultSort.field]: contentType.admin.defaultSort.direction } : { updatedAt: "desc" };
+  const searchableFields = contentType.admin?.searchableFields ?? ["title"];
+  return {
+    async getAll(options) {
+      const where = {};
+      if (options?.search) {
+        where.OR = searchableFields.map((field) => ({
+          [field]: { contains: options.search }
+        }));
+      }
+      if (options?.status) {
+        where.status = options.status;
+      }
+      return model.findMany({
+        where: Object.keys(where).length > 0 ? where : void 0,
+        orderBy: options?.orderBy ?? defaultSort
+      });
+    },
+    async getById(id) {
+      return model.findUnique({ where: { id } });
+    },
+    async create(data) {
+      const createData = {};
+      for (const field of contentType.fields) {
+        if (field.defaultValue !== void 0) {
+          createData[field.name] = field.defaultValue;
+        }
+      }
+      if (contentType.defaultStatus) {
+        createData.status = contentType.defaultStatus;
+      }
+      if (data) {
+        Object.assign(createData, data);
+      }
+      const record = await model.create({
+        data: createData
+      });
+      return record.id;
+    },
+    async update(id, data) {
+      const record = await model.findUnique({ where: { id } });
+      if (!record) throw new Error(`${contentType.labels.singular} not found`);
+      await model.update({
+        where: { id },
+        data: { ...data, updatedAt: /* @__PURE__ */ new Date() }
+      });
+      return { success: true };
+    },
+    async delete(id) {
+      const record = await model.findUnique({ where: { id } });
+      if (!record) throw new Error(`${contentType.labels.singular} not found`);
+      await model.delete({ where: { id } });
+      return { success: true };
+    },
+    async publish(userId, id) {
+      if (!contentType.publishedStatus) return { success: false };
+      const record = await model.findUnique({ where: { id } });
+      if (!record) throw new Error(`${contentType.labels.singular} not found`);
+      await model.update({
+        where: { id },
+        data: {
+          status: contentType.publishedStatus,
+          publishedAt: /* @__PURE__ */ new Date()
+        }
+      });
+      return { success: true };
+    },
+    async unpublish(id) {
+      if (!contentType.defaultStatus) return { success: false };
+      const record = await model.findUnique({ where: { id } });
+      if (!record) throw new Error(`${contentType.labels.singular} not found`);
+      await model.update({
+        where: { id },
+        data: {
+          status: contentType.defaultStatus,
+          publishedAt: null
+        }
+      });
+      return { success: true };
+    }
+  };
+}
 export {
   DEFAULT_CONFIG,
   buildAuthCallbacks,
   buildCredentialsProvider,
   createArticleHandlers,
   createAuthUtils,
+  createContentHandlers,
   createMediaHandlers,
   createRevisionHandlers,
   createUploadHandler,