@xleddyl/nuxt-cms 0.1.9

package/dist/module.mjs

@@ -0,0 +1,765 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { isAbsolute, resolve, relative, join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { defineNuxtModule, createResolver, useLogger, resolvePath, addTemplate, addImports, addServerPlugin, addTypeTemplate, addLayout, addComponentsDir, addRouteMiddleware, extendPages, addServerHandler } from '@nuxt/kit';
+import { introspectionFromSchema, buildSchema } from 'graphql';
+import { minifyIntrospection, outputIntrospectionFile } from 'gql.tada/internal';
+import { createJiti } from 'jiti';
+import { typeName, blockTypeName, blockUnionName, renderGraphqlSdl } from '../dist/runtime/shared/graphql-sdl.js';
+import { isTranslatableField } from '../dist/runtime/shared/index.js';
+
+const IDENTIFIER = /^[a-z_]\w*$/i;
+const RESERVED_ENTRY_KEYS = ["admin", "auth", "login", "media", "graphql", "cms_media"];
+const RESERVED_COLUMNS = ["id", "status", "created_at", "updated_at"];
+const RESERVED_TYPE_NAMES = [
+  "Query",
+  "Mutation",
+  "Subscription",
+  "CmsMedia",
+  "JSON",
+  "SortDirection",
+  "IntFilter",
+  "FloatFilter",
+  "StringFilter",
+  "BooleanFilter"
+];
+function validateConfig(config, i18n) {
+  const errors = [];
+  const locales = i18n?.locales ?? [];
+  if (locales.length && !locales.includes(i18n.defaultLocale)) {
+    errors.push(
+      `cms.i18n: defaultLocale '${i18n.defaultLocale}' is not in locales [${locales.join(
+        ", "
+      )}]`
+    );
+  }
+  const entryIds = /* @__PURE__ */ new Map();
+  const typeNames = /* @__PURE__ */ new Map();
+  for (const [name, entry] of Object.entries(config)) {
+    const at = `cms.config entry '${name}'`;
+    if (!IDENTIFIER.test(name)) errors.push(`${at}: key must be a valid identifier`);
+    if (RESERVED_ENTRY_KEYS.includes(name)) errors.push(`${at}: '${name}' is a reserved name`);
+    const gqlType = typeName(name);
+    if (RESERVED_TYPE_NAMES.includes(gqlType)) {
+      errors.push(`${at}: GraphQL type name '${gqlType}' is reserved`);
+    } else if (typeNames.has(gqlType)) {
+      errors.push(
+        `${at}: GraphQL type name '${gqlType}' clashes with entry '${typeNames.get(gqlType)}'`
+      );
+    } else {
+      typeNames.set(gqlType, name);
+    }
+    if (!entry.id) {
+      errors.push(`${at}: id is required`);
+    } else if (!IDENTIFIER.test(entry.id)) {
+      errors.push(`${at}: id '${entry.id}' must be a valid identifier`);
+    } else if (entryIds.has(entry.id)) {
+      errors.push(`${at}: id '${entry.id}' is already used by entry '${entryIds.get(entry.id)}'`);
+    } else {
+      entryIds.set(entry.id, name);
+    }
+    if (entry.kind !== "collection" && entry.kind !== "single")
+      errors.push(`${at}: kind must be 'collection' or 'single'`);
+    if (entry.drafts && entry.kind !== "collection")
+      errors.push(`${at}: drafts are only supported on collections`);
+    if (!entry.fields || !Object.keys(entry.fields).length)
+      errors.push(`${at}: fields must not be empty`);
+    if (entry.titleField && !entry.fields?.[entry.titleField])
+      errors.push(`${at}: titleField '${entry.titleField}' is not a declared field`);
+    const columnNames = /* @__PURE__ */ new Set();
+    for (const [key, field] of Object.entries(entry.fields ?? {})) {
+      const fat = `${at}, field '${key}'`;
+      if (!IDENTIFIER.test(key)) errors.push(`${fat}: key must be a valid identifier`);
+      const column = snakeCase(key);
+      if (RESERVED_COLUMNS.includes(column))
+        errors.push(`${fat}: column '${column}' is reserved`);
+      if (!isManyToMany(field)) {
+        if (columnNames.has(column))
+          errors.push(`${fat}: column '${column}' clashes with another field`);
+        columnNames.add(column);
+      }
+      if (field.translatable) {
+        if (field.type !== "text" && field.type !== "richtext")
+          errors.push(`${fat}: translatable is only supported on text and richtext fields`);
+        if (!locales.length)
+          errors.push(`${fat}: translatable requires cms.i18n.locales in nuxt.config`);
+      }
+      if (field.type === "select") {
+        if (!field.options?.length)
+          errors.push(`${fat}: select requires a non-empty options array`);
+        else if (new Set(field.options).size !== field.options.length)
+          errors.push(`${fat}: select options must be unique`);
+      }
+      if (field.type === "slug" && field.from) {
+        const source = entry.fields?.[field.from];
+        if (!source) errors.push(`${fat}: slug source '${field.from}' is not a declared field`);
+        else if (source.type !== "text")
+          errors.push(`${fat}: slug source '${field.from}' must be a text field`);
+        else if (isTranslatableField(source))
+          errors.push(`${fat}: slug source '${field.from}' cannot be translatable`);
+      }
+      if (field.type === "blocks") {
+        if (field.translatable) errors.push(`${fat}: blocks fields cannot be translatable`);
+        if (!field.blocks || !Object.keys(field.blocks).length) {
+          errors.push(`${fat}: blocks requires a non-empty blocks map`);
+        }
+        for (const [blockName, block] of Object.entries(field.blocks ?? {})) {
+          const bat = `${fat}, block '${blockName}'`;
+          if (!IDENTIFIER.test(blockName))
+            errors.push(`${bat}: key must be a valid identifier`);
+          if (!block.fields || !Object.keys(block.fields).length)
+            errors.push(`${bat}: fields must not be empty`);
+          for (const [blockFieldKey, blockField] of Object.entries(block.fields ?? {})) {
+            const bfat = `${bat}, field '${blockFieldKey}'`;
+            if (!IDENTIFIER.test(blockFieldKey))
+              errors.push(`${bfat}: key must be a valid identifier`);
+            if (blockFieldKey === "type")
+              errors.push(`${bfat}: 'type' is reserved inside blocks`);
+            if (["relation", "blocks", "slug"].includes(blockField.type)) {
+              errors.push(
+                `${bfat}: ${blockField.type} fields are not supported inside blocks`
+              );
+            }
+            if (blockField.translatable)
+              errors.push(`${bfat}: translatable fields are not supported inside blocks`);
+            if (blockField.type === "select" && !blockField.options?.length) {
+              errors.push(`${bfat}: select requires a non-empty options array`);
+            }
+          }
+        }
+      }
+      if (field.type === "relation") {
+        const target = field.to ? config[field.to] : void 0;
+        if (!field.to || !target) {
+          errors.push(`${fat}: relation target '${field.to}' is not in the registry`);
+        } else {
+          if (target.kind !== "collection")
+            errors.push(`${fat}: relation target '${field.to}' must be a collection`);
+          if (!entry.table && target.table)
+            errors.push(
+              `${fat}: relation target '${field.to}' uses a custom table \u2014 derived relations can only target derived entries`
+            );
+        }
+        if (field.cardinality && !["many-to-one", "one-to-one", "many-to-many"].includes(field.cardinality)) {
+          errors.push(`${fat}: unknown cardinality '${field.cardinality}'`);
+        }
+        if (field.required && field.onDelete === "set null")
+          errors.push(`${fat}: a required relation cannot use onDelete 'set null'`);
+        if (field.cardinality === "many-to-many") {
+          if (field.onDelete === "set null")
+            errors.push(`${fat}: many-to-many does not accept onDelete 'set null'`);
+          if (entry.table)
+            errors.push(`${fat}: many-to-many is not available on custom-table entries`);
+          if (config[`${name}_${key}`])
+            errors.push(`${fat}: '${name}_${key}' clashes with the derived join table name`);
+        }
+      }
+    }
+  }
+  const sqlTableNames = /* @__PURE__ */ new Map([["cms_media", "the built-in media table"]]);
+  for (const [name, entry] of Object.entries(config)) {
+    if (entry.table) continue;
+    const registerTable = (sqlName, source) => {
+      const existing = sqlTableNames.get(sqlName);
+      if (existing) {
+        errors.push(
+          `cms.config: table name '${sqlName}' from ${source} clashes with ${existing}`
+        );
+      } else {
+        sqlTableNames.set(sqlName, source);
+      }
+    };
+    registerTable(name, `entry '${name}'`);
+    for (const [key, field] of Object.entries(entry.fields ?? {})) {
+      if (isManyToMany(field))
+        registerTable(`${name}_${snakeCase(key)}`, `the join table of '${name}.${key}'`);
+    }
+  }
+  return errors;
+}
+function snakeCase(key) {
+  return key.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
+function jsonExpr(col, dialect) {
+  return dialect === "postgres" ? `jsonb('${col}')` : `text('${col}', { mode: 'json' })`;
+}
+function columnExpr(key, field, dialect) {
+  const col = snakeCase(key);
+  let expr;
+  if (isTranslatableField(field)) {
+    expr = jsonExpr(col, dialect);
+    if (field.required) expr += ".notNull()";
+    return `  ${key}: ${expr},`;
+  }
+  switch (field.type) {
+    case "number":
+      expr = field.integer ? `integer('${col}')` : dialect === "postgres" ? `doublePrecision('${col}')` : `real('${col}')`;
+      break;
+    case "boolean":
+      expr = dialect === "postgres" ? `boolean('${col}')` : `integer('${col}', { mode: 'boolean' })`;
+      break;
+    case "date":
+      expr = dialect === "postgres" ? `date('${col}', { mode: 'string' })` : `text('${col}')`;
+      break;
+    case "json":
+    case "blocks":
+      expr = jsonExpr(col, dialect);
+      break;
+    case "slug":
+      expr = `text('${col}').unique()`;
+      break;
+    case "relation": {
+      const onDelete = field.onDelete ?? (field.required ? "restrict" : "set null");
+      expr = `text('${col}').references(() => ${field.to}.id, { onDelete: '${onDelete}' })`;
+      if (field.cardinality === "one-to-one") expr += ".unique()";
+      break;
+    }
+    default:
+      expr = `text('${col}')`;
+  }
+  if (field.required) expr += ".notNull()";
+  return `  ${key}: ${expr},`;
+}
+function isManyToMany(field) {
+  return field.type === "relation" && field.cardinality === "many-to-many";
+}
+function autoIdExpr(pg) {
+  return pg ? `integer('id').primaryKey().generatedAlwaysAsIdentity()` : `integer('id').primaryKey({ autoIncrement: true })`;
+}
+function nowExpr(pg, col) {
+  return pg ? `timestamp('${col}', { mode: 'string' }).notNull().defaultNow()` : `text('${col}').notNull().default(sql\`(datetime('now'))\`)`;
+}
+function tableExpr(name, entry, dialect) {
+  const pg = dialect === "postgres";
+  const tableFn = pg ? "pgTable" : "sqliteTable";
+  const lines = [];
+  lines.push(`  id: text('id').primaryKey(),`);
+  for (const [key, field] of Object.entries(entry.fields)) {
+    if (isManyToMany(field)) continue;
+    lines.push(columnExpr(key, field, dialect));
+  }
+  if (entry.drafts) lines.push(`  status: text('status').notNull().default('draft'),`);
+  if (entry.kind === "collection") lines.push(`  createdAt: ${nowExpr(pg, "created_at")},`);
+  lines.push(`  updatedAt: ${nowExpr(pg, "updated_at")},`);
+  return `export const ${name} = ${tableFn}('${name}', {
+${lines.join("\n")}
+})`;
+}
+function joinTableExpr(name, key, field, dialect) {
+  const pg = dialect === "postgres";
+  const tableFn = pg ? "pgTable" : "sqliteTable";
+  const joinName = `${name}_${snakeCase(key)}`;
+  const targetOnDelete = field.onDelete ?? "cascade";
+  return `export const ${name}_${key} = ${tableFn}('${joinName}', {
+  sourceId: text('source_id').notNull().references(() => ${name}.id, { onDelete: 'cascade' }),
+  targetId: text('target_id').notNull().references(() => ${field.to}.id, { onDelete: '${targetOnDelete}' }),
+  position: integer('position').notNull().default(0),
+}, table => [primaryKey({ columns: [table.sourceId, table.targetId] })])`;
+}
+function mediaTableExpr(dialect) {
+  const pg = dialect === "postgres";
+  const tableFn = pg ? "pgTable" : "sqliteTable";
+  return `export const cms_media = ${tableFn}('cms_media', {
+  id: ${autoIdExpr(pg)},
+  key: text('key').notNull().unique(),
+  alt: text('alt'),
+  folder: text('folder'),
+  mime: text('mime'),
+  size: integer('size'),
+  width: integer('width'),
+  height: integer('height'),
+  createdAt: ${nowExpr(pg, "created_at")},
+})`;
+}
+function renderSchemaFile(config, dialect, resolveImport = (s) => s) {
+  const derived = Object.entries(config).filter(([, entry]) => !entry.table);
+  const fields = derived.flatMap(([, entry]) => Object.values(entry.fields));
+  const pg = dialect === "postgres";
+  const core = /* @__PURE__ */ new Set(["integer", "text", pg ? "pgTable" : "sqliteTable"]);
+  if (fields.some((f) => f.type === "number" && !f.integer))
+    core.add(pg ? "doublePrecision" : "real");
+  if (pg && fields.some((f) => f.type === "date")) core.add("date");
+  if (pg && fields.some((f) => f.type === "boolean")) core.add("boolean");
+  if (pg && fields.some((f) => f.type === "json" || f.type === "blocks" || isTranslatableField(f)))
+    core.add("jsonb");
+  if (pg) core.add("timestamp");
+  if (fields.some(isManyToMany)) core.add("primaryKey");
+  const imports = [
+    ...pg ? [] : [`import { sql } from '${resolveImport("drizzle-orm")}'`],
+    `import { ${[...core].sort().join(", ")} } from '${resolveImport(
+      `drizzle-orm/${pg ? "pg-core" : "sqlite-core"}`
+    )}'`
+  ];
+  const tables = derived.map(([name, entry]) => tableExpr(name, entry, dialect));
+  const joins = derived.flatMap(
+    ([name, entry]) => Object.entries(entry.fields).filter(([, field]) => isManyToMany(field)).map(([key, field]) => joinTableExpr(name, key, field, dialect))
+  );
+  return `${imports.join("\n")}
+
+${[mediaTableExpr(dialect), ...tables, ...joins].join(
+    "\n\n"
+  )}
+`;
+}
+
+function scalarTsType(field) {
+  switch (field.type) {
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "json":
+      return "unknown";
+    case "select":
+      return field.options.map((o) => JSON.stringify(o)).join(" | ");
+    default:
+      return "string";
+  }
+}
+function fieldTsType(config, entryName, key, field) {
+  if (field.type === "relation") {
+    const target = typeName(field.to);
+    if (field.cardinality === "many-to-many") return `${target}[]`;
+    return field.required && !config[field.to]?.drafts ? target : `${target} | null`;
+  }
+  if (field.type === "media") return "CmsMedia | null";
+  if (field.type === "blocks") {
+    const union = blockUnionName(entryName, key);
+    return field.required ? `${union}[]` : `${union}[] | null`;
+  }
+  if (isTranslatableField(field)) return field.required ? "string" : "string | null";
+  const base = scalarTsType(field);
+  return field.required ? base : `${base} | null`;
+}
+function blockTypesTs(entryName, key, field) {
+  const defs = [];
+  const members = [];
+  for (const [blockName, block] of Object.entries(field.blocks ?? {})) {
+    const name = blockTypeName(entryName, key, blockName);
+    members.push(name);
+    const lines = [`  __typename?: '${name}'`, `  type: '${blockName}'`];
+    for (const [blockFieldKey, blockField] of Object.entries(block.fields)) {
+      if (blockField.type === "media") {
+        lines.push(`  ${blockFieldKey}: CmsMedia | null`);
+        continue;
+      }
+      const base = scalarTsType(blockField);
+      lines.push(`  ${blockFieldKey}: ${blockField.required ? base : `${base} | null`}`);
+    }
+    defs.push(`export interface ${name} {
+${lines.join("\n")}
+}`);
+  }
+  if (members.length)
+    defs.push(`export type ${blockUnionName(entryName, key)} = ${members.join(" | ")}`);
+  return defs;
+}
+function entryTs(config, name, entry) {
+  const lines = ["  id: string"];
+  for (const [key, field] of Object.entries(entry.fields)) {
+    lines.push(`  ${key}: ${fieldTsType(config, name, key, field)}`);
+  }
+  if (entry.kind === "collection") lines.push("  createdAt: string");
+  lines.push("  updatedAt: string");
+  return `export interface ${typeName(name)} {
+${lines.join("\n")}
+}`;
+}
+function renderTypesFile(config) {
+  const parts = [
+    `export interface CmsMedia {
+  key: string
+  url: string | null
+  type: 'image' | 'video' | 'file'
+  alt: string | null
+  folder: string | null
+  mime: string | null
+  size: number | null
+  width: number | null
+  height: number | null
+}`
+  ];
+  for (const [name, entry] of Object.entries(config)) {
+    for (const [key, field] of Object.entries(entry.fields)) {
+      if (field.type === "blocks") parts.push(...blockTypesTs(name, key, field));
+    }
+    parts.push(entryTs(config, name, entry));
+  }
+  return `${parts.join("\n\n")}
+`;
+}
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "@xleddyl/nuxt-cms",
+    configKey: "cms"
+  },
+  moduleDependencies: {
+    "@nuxt/ui": {},
+    "nuxt-auth-utils": {},
+    "@nuxtjs/i18n": {
+      defaults: {
+        locales: [
+          { code: "en", name: "English" },
+          { code: "it", name: "Italiano" }
+        ],
+        defaultLocale: "en",
+        strategy: "no_prefix",
+        detectBrowserLanguage: {
+          useCookie: true,
+          cookieKey: "cms-locale",
+          fallbackLocale: "en"
+        }
+      }
+    }
+  },
+  defaults: {
+    configPath: "cms.config",
+    admin: {
+      email: "",
+      password: ""
+    },
+    database: {
+      driver: "sqlite",
+      path: "data/cms.db",
+      url: ""
+    },
+    media: {
+      endpoint: "",
+      region: "auto",
+      bucket: "",
+      publicBaseUrl: "",
+      presignExpiry: 600,
+      accessKeyId: "",
+      secretAccessKey: ""
+    },
+    i18n: {
+      locales: [],
+      defaultLocale: "en"
+    },
+    graphql: {
+      maxDepth: 8
+    }
+  },
+  async setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    const logger = useLogger("nuxt-cms");
+    const configPath = await resolvePath(options.configPath, { cwd: nuxt.options.rootDir });
+    nuxt.options.alias["#nuxt-cms"] = resolver.resolve("./runtime/shared/index");
+    nuxt.options.watch.push(configPath);
+    let cmsConfig = {};
+    if (existsSync(configPath)) {
+      nuxt.options.alias["#cms-config"] = configPath;
+      const jiti = createJiti(import.meta.url, {
+        moduleCache: false,
+        alias: { "#nuxt-cms": resolver.resolve("./runtime/shared/index") }
+      });
+      cmsConfig = await jiti.import(configPath, { default: true });
+    } else {
+      logger.warn(
+        `[nuxt-cms] Config file not found: ${configPath}. Using an empty registry \u2014 create a ${options.configPath}.ts with defineCmsConfig().`
+      );
+      nuxt.options.alias["#cms-config"] = resolver.resolve("./runtime/shared/empty-config");
+    }
+    const configErrors = validateConfig(cmsConfig, options.i18n);
+    if (configErrors.length) {
+      for (const error of configErrors) logger.error(error);
+      throw new Error(
+        `[nuxt-cms] Invalid cms config (${configErrors.length} error${configErrors.length > 1 ? "s" : ""})`
+      );
+    }
+    const moduleRequire = createRequire(import.meta.url);
+    const resolveImport = (specifier) => {
+      try {
+        return fileURLToPath(import.meta.resolve(specifier)).replace(/\\/g, "/");
+      } catch {
+        return moduleRequire.resolve(specifier).replace(/\\/g, "/");
+      }
+    };
+    const schemaTemplate = addTemplate({
+      filename: "cms/schema.ts",
+      write: true,
+      getContents: () => renderSchemaFile(cmsConfig, options.database.driver ?? "sqlite", resolveImport)
+    });
+    nuxt.options.alias["#cms-tables"] = schemaTemplate.dst;
+    addTemplate({
+      filename: "cms/schema.graphql",
+      write: true,
+      getContents: () => renderGraphqlSdl(cmsConfig)
+    });
+    const typesTemplate = addTemplate({
+      filename: "cms/types.ts",
+      write: true,
+      getContents: () => renderTypesFile(cmsConfig)
+    });
+    nuxt.options.alias["#cms-types"] = typesTemplate.dst;
+    addTemplate({
+      filename: "cms/graphql-env.d.ts",
+      write: true,
+      getContents: () => {
+        const introspection = minifyIntrospection(
+          introspectionFromSchema(buildSchema(renderGraphqlSdl(cmsConfig)))
+        );
+        return outputIntrospectionFile(introspection, {
+          fileType: ".d.ts",
+          shouldPreprocess: true
+        }).split("import * as gqlTada from 'gql.tada';")[0];
+      }
+    });
+    const gqlTadaTypesPath = resolveImport("gql.tada").replace(/\.[mc]?js$/, "");
+    const graphqlTemplate = addTemplate({
+      filename: "cms/graphql.ts",
+      write: true,
+      getContents: () => [
+        `import type { initGraphQLTada, ResultOf, VariablesOf } from '${gqlTadaTypesPath}'`,
+        `import type { introspection } from './graphql-env'`,
+        ``,
+        `export type CmsGraphql = initGraphQLTada<{`,
+        `  introspection: introspection`,
+        `  scalars: {`,
+        `    JSON: unknown`,
+        `  }`,
+        `}>`,
+        ``,
+        `declare const graphql: CmsGraphql`,
+        ``,
+        `// @ts-ignore: gql.tada's cache overload rejects this instantiation, but the parse overload still resolves`,
+        `export type CmsDocument<Query extends string> = ReturnType<typeof graphql<Query, []>>`,
+        ``,
+        `export type CmsResult<Query extends string> = string extends Query`,
+        `  ? Record<string, unknown>`,
+        `  : ResultOf<CmsDocument<Query>>`,
+        ``,
+        `export type CmsVariables<Query extends string> = string extends Query`,
+        `  ? Record<string, unknown>`,
+        `  : VariablesOf<CmsDocument<Query>>`,
+        ``
+      ].join("\n")
+    });
+    nuxt.options.alias["#cms-graphql"] = graphqlTemplate.dst;
+    addImports([
+      { name: "useCms", from: resolver.resolve("./runtime/app/composables/cms-query") },
+      { name: "$cmsQuery", from: resolver.resolve("./runtime/app/composables/cms-query") }
+    ]);
+    nuxt.hook("i18n:registerModule", (register) => {
+      register({
+        langDir: resolver.resolve("./runtime/app/i18n"),
+        locales: [
+          { code: "en", file: "en.json" },
+          { code: "it", file: "it.json" }
+        ]
+      });
+    });
+    const { driver = "sqlite", path: dbPath = "data/cms.db", url: databaseUrl = "" } = options.database;
+    nuxt.options.alias["#cms-db"] = resolver.resolve(
+      driver === "postgres" ? "./runtime/server/utils/db-postgres" : "./runtime/server/utils/db-sqlite"
+    );
+    const dialect = driver === "postgres" ? "postgresql" : "sqlite";
+    const resolvedDbPath = isAbsolute(dbPath) ? dbPath : resolve(nuxt.options.rootDir, dbPath);
+    const migrationsDir = resolve(nuxt.options.rootDir, `server/db/migrations/${driver}`);
+    const relativeSchemaPath = relative(nuxt.options.rootDir, schemaTemplate.dst);
+    const relativeMigrationsDir = relative(nuxt.options.rootDir, migrationsDir);
+    const toPosix = (path) => path.replace(/\\/g, "/");
+    addTemplate({
+      filename: "cms/drizzle.config.ts",
+      write: true,
+      getContents: () => [
+        `export default {`,
+        `  dialect: '${dialect}',`,
+        `  schema: '${toPosix(schemaTemplate.dst)}',`,
+        `  out: '${toPosix(migrationsDir)}',`,
+        driver === "postgres" ? `  dbCredentials: { url: process.env.NUXT_CMS_DATABASE_URL ?? '${databaseUrl}' },` : `  dbCredentials: { url: '${toPosix(resolvedDbPath)}' },`,
+        `}`,
+        ``
+      ].join("\n")
+    });
+    addServerPlugin(
+      resolver.resolve(
+        driver === "postgres" ? "./runtime/server/plugins/migrate-postgres" : "./runtime/server/plugins/migrate-sqlite"
+      )
+    );
+    if (!nuxt.options.dev) {
+      addServerPlugin(resolver.resolve("./runtime/server/plugins/session-check"));
+    }
+    if (nuxt.options.dev) {
+      let generated = false;
+      nuxt.hook("app:templatesGenerated", async () => {
+        if (generated) return;
+        generated = true;
+        const bin = join(dirname(moduleRequire.resolve("drizzle-kit")), "bin.cjs");
+        const args = [
+          bin,
+          "generate",
+          `--dialect=${dialect}`,
+          `--schema=${relativeSchemaPath}`,
+          `--out=${relativeMigrationsDir}`
+        ];
+        const code = await new Promise((done) => {
+          spawn(process.execPath, args, { cwd: nuxt.options.rootDir, stdio: "inherit" }).on("close", (exitCode) => done(exitCode ?? 1)).on("error", () => done(1));
+        });
+        if (code !== 0)
+          logger.error(`[nuxt-cms] drizzle-kit generate failed (exit code ${code})`);
+      });
+    }
+    const existingConfig = nuxt.options.runtimeConfig.cms ?? {};
+    nuxt.options.runtimeConfig.cms = {
+      adminEmail: options.admin.email,
+      adminPassword: options.admin.password,
+      databaseUrl,
+      dbPath: resolvedDbPath,
+      migrationsDir,
+      ...existingConfig,
+      graphql: {
+        graphiql: nuxt.options.dev,
+        maxDepth: options.graphql.maxDepth,
+        ...existingConfig.graphql ?? {}
+      },
+      media: {
+        endpoint: options.media.endpoint,
+        region: options.media.region,
+        bucket: options.media.bucket,
+        presignExpiry: options.media.presignExpiry,
+        accessKeyId: options.media.accessKeyId,
+        secretAccessKey: options.media.secretAccessKey,
+        ...existingConfig.media ?? {}
+      }
+    };
+    nuxt.options.runtimeConfig.public.cms = {
+      mediaBaseUrl: options.media.publicBaseUrl,
+      i18n: options.i18n
+    };
+    addTypeTemplate(
+      {
+        filename: "types/nuxt-cms-auth.d.ts",
+        getContents: () => [
+          "import type { H3Event } from 'h3'",
+          "",
+          "declare module '#auth-utils' {",
+          "  interface User {",
+          "    email: string",
+          "  }",
+          "}",
+          "",
+          "declare module '#imports' {",
+          "  function getUserSession(event: H3Event): Promise<{ user?: import('#auth-utils').User }>",
+          "  function setUserSession(event: H3Event, session: { user: import('#auth-utils').User }): Promise<unknown>",
+          "}",
+          "",
+          "export {}",
+          ""
+        ].join("\n")
+      },
+      { nuxt: true, nitro: true }
+    );
+    nuxt.options.css.push(resolver.resolve("./runtime/assets/main.css"));
+    addLayout({ src: resolver.resolve("./runtime/app/layouts/cms-admin.vue") }, "cms-admin");
+    addComponentsDir({ path: resolver.resolve("./runtime/app/components") });
+    addRouteMiddleware({
+      name: "cms-auth",
+      path: resolver.resolve("./runtime/app/middleware/cms-auth")
+    });
+    extendPages((pages) => {
+      pages.unshift(
+        {
+          name: "cms-admin",
+          path: "/cms",
+          file: resolver.resolve("./runtime/app/pages/admin-index.vue")
+        },
+        {
+          name: "cms-admin-login",
+          path: "/cms/login",
+          file: resolver.resolve("./runtime/app/pages/admin-login.vue")
+        },
+        {
+          name: "cms-admin-media",
+          path: "/cms/media",
+          file: resolver.resolve("./runtime/app/pages/admin-media.vue")
+        },
+        {
+          name: "cms-admin-collection",
+          path: "/cms/:collection()",
+          file: resolver.resolve("./runtime/app/pages/admin-collection.vue")
+        },
+        {
+          name: "cms-admin-entry-new",
+          path: "/cms/:collection()/new",
+          file: resolver.resolve("./runtime/app/pages/admin-entry.vue")
+        },
+        {
+          name: "cms-admin-entry",
+          path: "/cms/:collection()/:id()",
+          file: resolver.resolve("./runtime/app/pages/admin-entry.vue")
+        }
+      );
+    });
+    addServerHandler({
+      route: "/api/cms/auth/login",
+      method: "post",
+      handler: resolver.resolve("./runtime/server/routes/auth/login.post")
+    });
+    addServerHandler({
+      route: "/api/cms/admin/media/presign",
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/media-presign.post")
+    });
+    addServerHandler({
+      route: "/api/cms/admin/media",
+      method: "get",
+      handler: resolver.resolve("./runtime/server/api/media.get")
+    });
+    addServerHandler({
+      route: "/api/cms/admin/media",
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/media.post")
+    });
+    addServerHandler({
+      route: "/api/cms/admin/media",
+      method: "put",
+      handler: resolver.resolve("./runtime/server/api/media.put")
+    });
+    addServerHandler({
+      route: "/api/cms/admin/media",
+      method: "delete",
+      handler: resolver.resolve("./runtime/server/api/media.delete")
+    });
+    const api = "/api/cms/admin/:collection";
+    addServerHandler({
+      route: api,
+      method: "get",
+      handler: resolver.resolve("./runtime/server/api/collection.get")
+    });
+    addServerHandler({
+      route: api,
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/collection.post")
+    });
+    addServerHandler({
+      route: api,
+      method: "put",
+      handler: resolver.resolve("./runtime/server/api/collection.put")
+    });
+    addServerHandler({
+      route: `${api}/:id`,
+      method: "get",
+      handler: resolver.resolve("./runtime/server/api/item.get")
+    });
+    addServerHandler({
+      route: `${api}/:id`,
+      method: "put",
+      handler: resolver.resolve("./runtime/server/api/item.put")
+    });
+    addServerHandler({
+      route: `${api}/:id`,
+      method: "delete",
+      handler: resolver.resolve("./runtime/server/api/item.delete")
+    });
+    addServerHandler({
+      route: "/api/cms/graphql",
+      handler: resolver.resolve("./runtime/server/routes/graphql")
+    });
+  }
+});
+
+export { module$1 as default };