@lupinum/ginko-content 0.3.2 → 0.3.4

package/dist/cms-contract/build.js

@@ -84,20 +84,20 @@ function fieldFromSchema(key, schema, localized) {
   const required = !["ZodOptional", "ZodNullable", "ZodDefault"].includes(getSchemaTypeName(schema) ?? "");
   if (metadata) return fieldFromMetadata(key, metadata, schema, unwrapped, localized, required);
   const reference = getReferenceDescriptor(unwrapped);
-  if (reference) return field({ key, type: "relation", required, default: defaultFromSchema(schema), relation: { collection: reference.collection ?? "", multiple: false } });
+  if (reference) return field({ key, type: "relation", required, default: defaultFromSchema(schema, key), relation: { collection: reference.collection ?? "", multiple: false } });
   const typeName = getSchemaTypeName(unwrapped);
-  if (typeName === "ZodObject") return field({ key, type: "object", required, localized, default: defaultFromSchema(schema), fields: nestedFields(unwrapped), validation: validationFromSchema(schema) });
+  if (typeName === "ZodObject") return field({ key, type: "object", required, localized, default: defaultFromSchema(schema, key), fields: nestedFields(unwrapped), validation: validationFromSchema(schema) });
   if (typeName === "ZodArray") {
     const element = getSchemaDef(unwrapped)?.element;
     const relation = getReferenceDescriptor(unwrapSchema(element));
-    if (relation) return field({ key, type: "relations", required, default: defaultFromSchema(schema), relation: { collection: relation.collection ?? "", multiple: true } });
+    if (relation) return field({ key, type: "relations", required, default: defaultFromSchema(schema, key), relation: { collection: relation.collection ?? "", multiple: true } });
     const children = getSchemaTypeName(unwrapSchema(element)) === "ZodObject" ? nestedFields(element) : null;
-    return field({ key, type: children ? "array" : "json", required, localized, default: defaultFromSchema(schema), fields: children, validation: validationFromSchema(schema) });
+    return field({ key, type: children ? "array" : "json", required, localized, default: defaultFromSchema(schema, key), fields: children, validation: validationFromSchema(schema) });
   }
-  if (typeName === "ZodNumber") return field({ key, type: "number", required, default: defaultFromSchema(schema), validation: validationFromSchema(schema) });
-  if (typeName === "ZodBoolean") return field({ key, type: "toggle", required, default: defaultFromSchema(schema), validation: validationFromSchema(schema) });
-  if (typeName === "ZodDate") return field({ key, type: "date", required, default: defaultFromSchema(schema), validation: validationFromSchema(schema) });
-  return field({ key, type: typeName === "ZodString" ? "text" : "json", required, localized, default: defaultFromSchema(schema), validation: validationFromSchema(schema) });
+  if (typeName === "ZodNumber") return field({ key, type: "number", required, default: defaultFromSchema(schema, key), validation: validationFromSchema(schema) });
+  if (typeName === "ZodBoolean") return field({ key, type: "toggle", required, default: defaultFromSchema(schema, key), validation: validationFromSchema(schema) });
+  if (typeName === "ZodDate") return field({ key, type: "date", required, default: defaultFromSchema(schema, key), validation: validationFromSchema(schema) });
+  return field({ key, type: typeName === "ZodString" ? "text" : "json", required, localized, default: defaultFromSchema(schema, key), validation: validationFromSchema(schema) });
 }
 function fieldFromMetadata(key, metadata, sourceSchema, schema, localized, required) {
   const type = metadata.type === "boolean" ? "toggle" : metadata.type === "asset" ? "file" : metadata.type;
@@ -107,7 +107,7 @@ function fieldFromMetadata(key, metadata, sourceSchema, schema, localized, requi
     type,
     required: metadata.required ?? required,
     localized: metadata.localized ?? localized,
-    default: defaultFromSchema(sourceSchema),
+    default: defaultFromSchema(sourceSchema, key),
     options: metadata.options ?? null,
     relation: metadata.relation ? { collection: metadata.relation.collectionId, multiple: metadata.relation.multiple ?? type === "relations" } : null,
     media: metadata.image || metadata.asset ? { mediaTypes: portableMediaTypes(metadata.image?.accept ?? metadata.asset?.accept), aspectRatio: metadata.image?.aspectRatio ?? null } : null,
@@ -132,7 +132,7 @@ function mergeField(existing, key, override, localized) {
     localized: override.localized ?? base.localized,
     searchable: override.searchable ?? base.searchable,
     sortable: override.sortable ?? base.sortable,
-    default: Object.prototype.hasOwnProperty.call(override, "defaultValue") ? { present: true, value: override.defaultValue } : base.default,
+    default: Object.prototype.hasOwnProperty.call(override, "defaultValue") ? { present: true, value: jsonDefault(override.defaultValue, key) } : base.default,
     options: override.options ?? base.options,
     relation: override.relation ? { collection: override.relation.collectionId, multiple: override.relation.multiple ?? type === "relations" } : base.relation,
     fields: override.fields ? configuredFields(override.fields, false) : base.fields,
@@ -143,17 +143,45 @@ function mergeField(existing, key, override, localized) {
     language: override.language ?? base.language
   });
 }
-function defaultFromSchema(schema) {
+function defaultFromSchema(schema, key) {
   let current = schema;
   while (current) {
     const typeName = getSchemaTypeName(current);
     const definition = getSchemaDef(current);
-    if (typeName === "ZodDefault") return { present: true, value: definition?.defaultValue };
+    if (typeName === "ZodDefault") return { present: true, value: jsonDefault(definition?.defaultValue, key) };
     if (!["ZodOptional", "ZodNullable"].includes(typeName ?? "")) break;
     current = definition?.innerType;
   }
   return { present: false };
 }
+function jsonDefault(value, key, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError(`Field "${key}" has a non-finite default value.`);
+    return value;
+  }
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) throw new TypeError(`Field "${key}" has an invalid date default.`);
+    return value.toISOString();
+  }
+  if (typeof value !== "object" || value === null) throw new TypeError(`Field "${key}" has a non-JSON-serializable default value.`);
+  if (ancestors.has(value)) throw new TypeError(`Field "${key}" has a cyclic default value.`);
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) return value.map((entry, index) => jsonDefault(entry, `${key}[${index}]`, ancestors));
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) throw new TypeError(`Field "${key}" has a non-JSON-serializable default value.`);
+    if (Object.getOwnPropertySymbols(value).length > 0) throw new TypeError(`Field "${key}" has a non-JSON-serializable default value.`);
+    const result = {};
+    for (const [property, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+      if (!descriptor.enumerable || !("value" in descriptor)) throw new TypeError(`Field "${key}" has a non-JSON-serializable default value.`);
+      result[property] = jsonDefault(descriptor.value, `${key}.${property}`, ancestors);
+    }
+    return result;
+  } finally {
+    ancestors.delete(value);
+  }
+}
 function validationFromSchema(schema, semanticType) {
   const typeName = getSchemaTypeName(schema);
   const definition = getSchemaDef(schema);
@@ -170,16 +198,16 @@ function validationFromSchema(schema, semanticType) {
     const format = ["email", "url", "date", "datetime", "time"].includes(String(value.format)) ? value.format : null;
     return {
       kind: "string",
-      minLength: typeof value.minLength === "number" ? value.minLength : null,
-      maxLength: typeof value.maxLength === "number" ? value.maxLength : null,
+      minLength: finiteNumber(value.minLength),
+      maxLength: finiteNumber(value.maxLength),
       format
     };
   }
   if (typeName === "ZodNumber") {
     return {
       kind: "number",
-      min: typeof value.minValue === "number" ? value.minValue : null,
-      max: typeof value.maxValue === "number" ? value.maxValue : null,
+      min: finiteNumber(value.minValue),
+      max: finiteNumber(value.maxValue),
       integer: value.isInt === true
     };
   }
@@ -210,12 +238,17 @@ function arrayLimits(checks) {
   if (Array.isArray(checks)) {
     for (const check of checks) {
       const definition = check._zod?.def ?? check.def;
-      if (definition?.check === "min_length" && typeof definition.minimum === "number") minItems = definition.minimum;
-      if (definition?.check === "max_length" && typeof definition.maximum === "number") maxItems = definition.maximum;
+      const minimum = finiteNumber(definition?.minimum);
+      const maximum = finiteNumber(definition?.maximum);
+      if (definition?.check === "min_length" && minimum !== null) minItems = minimum;
+      if (definition?.check === "max_length" && maximum !== null) maxItems = maximum;
     }
   }
   return { minItems, maxItems };
 }
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
 function configuredFields(input, localized) {
   const entries = Array.isArray(input) ? input.map((value, index) => [String(index), value]) : Object.entries(input);
   return entries.flatMap(([key, value]) => value.type === "divider" || value.type === "section" ? [] : [mergeField(void 0, key, value, localized)]);

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@lupinum/ginko-content",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "configKey": "content",
   "compatibility": {
     "nuxt": ">=4.4.7 <5"

package/dist/module.mjs

@@ -4,7 +4,8 @@ import { readFile, readdir, rm } from 'node:fs/promises';
 import { join as join$1, basename, resolve as resolve$1, dirname, isAbsolute as isAbsolute$1 } from 'node:path';
 import { buildResolvedContentContract } from '../dist/cms-contract/index.js';
 import fs, { existsSync } from 'fs';
-import { join, relative, resolve, isAbsolute } from 'pathe';
+import { createRequire } from 'node:module';
+import { join, relative, isAbsolute, resolve } from 'pathe';
 import jiti from 'jiti';
 import { genSafeVariableName, genImport } from 'knitwork';
 import { hash } from 'ohash';
@@ -29,7 +30,7 @@ import { createRouterMatcher } from 'vue-router';
 import { globby } from 'globby';
 
 const name = "@lupinum/ginko-content";
-const version = "0.3.2";
+const version = "0.3.4";
 const peerDependencies = {
 	nuxt: ">=4.4.7 <5"};
 
@@ -40,6 +41,17 @@ const CONFIG_FILES = [
   "content.config.mjs",
   "content.config.cjs"
 ];
+const isLocalModule = (filename, rootDir) => {
+  const localPath = relative(rootDir, filename);
+  return Boolean(localPath) && !localPath.startsWith("../") && !isAbsolute(localPath) && !localPath.split("/").includes("node_modules");
+};
+const clearLocalNativeModules = (cache, rootDir) => {
+  for (const [id, entry] of Object.entries(cache)) {
+    if (entry && isLocalModule(entry.filename, rootDir)) {
+      Reflect.deleteProperty(cache, id);
+    }
+  }
+};
 function resolveContentConfigPath(nuxt) {
   return CONFIG_FILES.map((name) => join(nuxt.options.rootDir, name)).find((path) => existsSync(path));
 }
@@ -48,8 +60,21 @@ async function loadContentConfig(nuxt) {
   if (!configPath) {
     return {};
   }
-  const importer = jiti(nuxt.options.rootDir, { interopDefault: true });
-  const loaded = await importer.import(configPath);
+  const nativeRequire = createRequire(configPath);
+  clearLocalNativeModules(nativeRequire.cache, nuxt.options.rootDir);
+  const importer = jiti(nuxt.options.rootDir, {
+    interopDefault: true,
+    // Nuxt reloads module setup in the same process for `options.watch`
+    // changes. The authored config and its imports must not come from the
+    // previous setup's module cache.
+    moduleCache: false
+  });
+  let loaded;
+  try {
+    loaded = importer(configPath);
+  } finally {
+    clearLocalNativeModules(nativeRequire.cache, nuxt.options.rootDir);
+  }
   return loaded?.default || loaded || {};
 }
 
@@ -193,11 +218,8 @@ const registerContentDevRuntime = (nuxt, options, contentContext) => {
   const isIgnored = makeIgnored(contentContext.ignores);
   let viteServer;
   if (options.watch !== false) {
-    nuxt.options.vite ||= {};
-    nuxt.options.vite.plugins ||= [];
-    nuxt.options.vite.plugins.push({
-      name: "ginko-content-hmr",
-      configureServer(server) {
+    nuxt.hook("vite:serverCreated", (server, environment) => {
+      if (environment.isClient) {
         viteServer = server;
       }
     });
@@ -1868,6 +1890,12 @@ const module$1 = defineNuxtModule({
       noExternal: runtimeInlineDependencies
     });
     const contentConfigPath = resolveContentConfigPath(nuxt);
+    if (nuxt.options.dev && options.watch !== false && contentConfigPath) {
+      nuxt.options.watch ||= [];
+      if (!nuxt.options.watch.includes(contentConfigPath)) {
+        nuxt.options.watch.push(contentConfigPath);
+      }
+    }
     const appContentConfig = await loadContentConfig(nuxt);
     if (!contentConfigPath || !appContentConfig.collections || !Object.keys(appContentConfig.collections).length) {
       throw new Error("@lupinum/ginko-content requires a content.config.ts with at least one collection. Define collections with defineContentConfig({ collections: { ... } }).");
@@ -1935,7 +1963,12 @@ const module$1 = defineNuxtModule({
       search: resolvedSearch,
       validation: options.validation || "report"
     };
-    await rm(resolve$1(nuxt.options.buildDir, "content-cache/validation.json"), { force: true });
+    const contentCacheDir = resolve$1(nuxt.options.buildDir, "content-cache");
+    if (nuxt.options.dev) {
+      await rm(contentCacheDir, { recursive: true, force: true });
+    } else {
+      await rm(resolve$1(contentCacheDir, "validation.json"), { force: true });
+    }
     const layers = nuxt.options._layers || [{ cwd: nuxt.options.rootDir, config: {} }];
     const nitroPublicAssets = nuxt.options.nitro?.publicAssets || [];
     contentContext.validationPublicAssets = await collectContentValidationPublicAssets({

package/dist/runtime/app/plugins/hot-reload.d.ts

@@ -1,2 +1,6 @@
+type ContentHot = {
+    on: (event: 'ginko-content:update', callback: (data: unknown) => void) => void;
+};
+export declare function registerContentHotReload(hot: ContentHot | undefined, isClient: boolean, refresh: () => unknown): void;
 declare const _default: any;
 export default _default;

package/dist/runtime/app/plugins/hot-reload.js

@@ -1,6 +1,14 @@
-import { defineNuxtPlugin } from "#imports";
-export default defineNuxtPlugin(() => {
-  if (import.meta.client && import.meta.hot) {
-    import("../composables/hot-reload.js").then(({ registerContentHotReload }) => registerContentHotReload());
+import { defineNuxtPlugin, refreshNuxtData } from "#imports";
+export function registerContentHotReload(hot, isClient, refresh) {
+  if (!hot || !isClient) {
+    return;
   }
+  hot.on("ginko-content:update", (data) => {
+    if (data && typeof data === "object") {
+      refresh();
+    }
+  });
+}
+export default defineNuxtPlugin(() => {
+  registerContentHotReload(import.meta.hot, import.meta.client, refreshNuxtData);
 });

package/dist/web-types.json

@@ -1,7 +1,7 @@
 {
   "framework": "vue",
   "name": "@lupinum/ginko-content",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "contributions": {
     "html": {
       "description-markup": "markdown",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lupinum/ginko-content",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Collection-first content engine for Nuxt",
   "homepage": "https://github.com/lupinum-dev/ginko-content",
   "bugs": {

package/dist/runtime/app/composables/hot-reload.d.ts

@@ -1,5 +0,0 @@
-type ContentHot = {
-    on: (event: 'ginko-content:update', callback: (data: unknown) => void) => void;
-};
-export declare function registerContentHotReload(hot?: ContentHot | undefined, isClient?: boolean | undefined): void;
-export {};

package/dist/runtime/app/composables/hot-reload.js

@@ -1,15 +0,0 @@
-import { refreshNuxtData } from "#imports";
-let registered = false;
-const onContentUpdate = (data) => {
-  if (!data || typeof data !== "object") {
-    return;
-  }
-  refreshNuxtData();
-};
-export function registerContentHotReload(hot = import.meta.hot, isClient = import.meta.client) {
-  if (!hot || !isClient || registered) {
-    return;
-  }
-  registered = true;
-  hot.on("ginko-content:update", onContentUpdate);
-}